Auto-update from upstream

313 files changed, 13214 insertions, 5136 deletions

diff --git a/arch/alpha/kernel/alpha_ksyms.c b/arch/alpha/kernel/alpha_ksyms.c
index 2b245ad731ee..d3848c5b0d2b 100644
--- a/arch/alpha/kernel/alpha_ksyms.c
+++ b/arch/alpha/kernel/alpha_ksyms.c
@@ -53,10 +53,6 @@ extern void __divqu (void);
 extern void __remqu (void);
 
 EXPORT_SYMBOL(alpha_mv);
-EXPORT_SYMBOL(enable_irq);
-EXPORT_SYMBOL(disable_irq);
-EXPORT_SYMBOL(disable_irq_nosync);
-EXPORT_SYMBOL(probe_irq_mask);
 EXPORT_SYMBOL(screen_info);
 EXPORT_SYMBOL(perf_irq);
 EXPORT_SYMBOL(callback_getenv);
@@ -68,19 +64,13 @@ EXPORT_SYMBOL(alpha_using_srm);
 
 /* platform dependent support */
 EXPORT_SYMBOL(strcat);
-EXPORT_SYMBOL(strcmp);
 EXPORT_SYMBOL(strcpy);
 EXPORT_SYMBOL(strlen);
-EXPORT_SYMBOL(strncmp);
 EXPORT_SYMBOL(strncpy);
-EXPORT_SYMBOL(strnlen);
 EXPORT_SYMBOL(strncat);
-EXPORT_SYMBOL(strstr);
 EXPORT_SYMBOL(strchr);
 EXPORT_SYMBOL(strrchr);
-EXPORT_SYMBOL(memcmp);
 EXPORT_SYMBOL(memmove);
-EXPORT_SYMBOL(memscan);
 EXPORT_SYMBOL(__memcpy);
 EXPORT_SYMBOL(__memset);
 EXPORT_SYMBOL(__memsetw);
@@ -122,11 +112,9 @@ EXPORT_SYMBOL(alpha_write_fp_reg_s);
 
 /* In-kernel system calls.  */
 EXPORT_SYMBOL(kernel_thread);
-EXPORT_SYMBOL(sys_open);
 EXPORT_SYMBOL(sys_dup);
 EXPORT_SYMBOL(sys_exit);
 EXPORT_SYMBOL(sys_write);
-EXPORT_SYMBOL(sys_read);
 EXPORT_SYMBOL(sys_lseek);
 EXPORT_SYMBOL(execve);
 EXPORT_SYMBOL(sys_setsid);
diff --git a/arch/alpha/kernel/osf_sys.c b/arch/alpha/kernel/osf_sys.c
index 31afe3d91ac6..e15dcf4f3dcd 100644
--- a/arch/alpha/kernel/osf_sys.c
+++ b/arch/alpha/kernel/osf_sys.c
@@ -244,7 +244,7 @@ do_osf_statfs(struct dentry * dentry, struct osf_statfs __user *buffer,
               unsigned long bufsiz)
 {
         struct kstatfs linux_stat;
-        int error = vfs_statfs(dentry->d_inode->i_sb, &linux_stat);
+        int error = vfs_statfs(dentry, &linux_stat);
         if (!error)
                 error = linux_to_osf_statfs(&linux_stat, buffer, bufsiz);
         return error;   
diff --git a/arch/alpha/kernel/signal.c b/arch/alpha/kernel/signal.c
index 2e45e8604e32..741da0945dc4 100644
--- a/arch/alpha/kernel/signal.c
+++ b/arch/alpha/kernel/signal.c
@@ -375,7 +375,7 @@ give_sigsegv:
 static inline void __user *
 get_sigframe(struct k_sigaction *ka, unsigned long sp, size_t frame_size)
 {
-        if ((ka->sa.sa_flags & SA_ONSTACK) != 0 && ! on_sig_stack(sp))
+        if ((ka->sa.sa_flags & SA_ONSTACK) != 0 && ! sas_ss_flags(sp))
                 sp = current->sas_ss_sp + current->sas_ss_size;
 
         return (void __user *)((sp - frame_size) & -32ul);
diff --git a/arch/arm/common/Makefile b/arch/arm/common/Makefile
index 847e3e6356c6..e1289a256ce5 100644
--- a/arch/arm/common/Makefile
+++ b/arch/arm/common/Makefile
@@ -16,3 +16,4 @@ obj-$(CONFIG_SHARP_PARAM)	+= sharpsl_param.o
 obj-$(CONFIG_SHARPSL_PM)        += sharpsl_pm.o
 obj-$(CONFIG_SHARP_SCOOP)       += scoop.o
 obj-$(CONFIG_ARCH_IXP2000)      += uengine.o
+obj-$(CONFIG_ARCH_IXP23XX)      += uengine.o
diff --git a/arch/arm/common/dmabounce.c b/arch/arm/common/dmabounce.c
index 7971d0dc6892..5b7c26395b44 100644
--- a/arch/arm/common/dmabounce.c
+++ b/arch/arm/common/dmabounce.c
@@ -77,6 +77,8 @@ struct dmabounce_device_info {
 #endif
         struct dmabounce_pool   small;
         struct dmabounce_pool   large;
+
+        rwlock_t lock;
 };
 
 static LIST_HEAD(dmabounce_devs);
@@ -116,6 +118,7 @@ alloc_safe_buffer(struct dmabounce_device_info *device_info, void *ptr,
         struct safe_buffer *buf;
         struct dmabounce_pool *pool;
         struct device *dev = device_info->dev;
+        unsigned long flags;
 
         dev_dbg(dev, "%s(ptr=%p, size=%d, dir=%d)\n",
                 __func__, ptr, size, dir);
@@ -163,8 +166,12 @@ alloc_safe_buffer(struct dmabounce_device_info *device_info, void *ptr,
                 print_alloc_stats(device_info);
 #endif
 
+        write_lock_irqsave(&device_info->lock, flags);
+
         list_add(&buf->node, &device_info->safe_buffers);
 
+        write_unlock_irqrestore(&device_info->lock, flags);
+
         return buf;
 }
 
@@ -172,22 +179,32 @@ alloc_safe_buffer(struct dmabounce_device_info *device_info, void *ptr,
 static inline struct safe_buffer *
 find_safe_buffer(struct dmabounce_device_info *device_info, dma_addr_t safe_dma_addr)
 {
-        struct safe_buffer *b;
+        struct safe_buffer *b = NULL;
+        unsigned long flags;
+
+        read_lock_irqsave(&device_info->lock, flags);
 
         list_for_each_entry(b, &device_info->safe_buffers, node)
                 if (b->safe_dma_addr == safe_dma_addr)
-                        return b;
+                        break;
 
-        return NULL;
+        read_unlock_irqrestore(&device_info->lock, flags);
+        return b;
 }
 
 static inline void
 free_safe_buffer(struct dmabounce_device_info *device_info, struct safe_buffer *buf)
 {
+        unsigned long flags;
+
         dev_dbg(device_info->dev, "%s(buf=%p)\n", __func__, buf);
 
+        write_lock_irqsave(&device_info->lock, flags);
+
         list_del(&buf->node);
 
+        write_unlock_irqrestore(&device_info->lock, flags);
+
         if (buf->pool)
                 dma_pool_free(buf->pool->pool, buf->safe, buf->safe_dma_addr);
         else
@@ -396,7 +413,6 @@ dma_addr_t
 dma_map_single(struct device *dev, void *ptr, size_t size,
                 enum dma_data_direction dir)
 {
-        unsigned long flags;
         dma_addr_t dma_addr;
 
         dev_dbg(dev, "%s(ptr=%p,size=%d,dir=%x)\n",
@@ -404,12 +420,8 @@ dma_map_single(struct device *dev, void *ptr, size_t size,
 
         BUG_ON(dir == DMA_NONE);
 
-        local_irq_save(flags);
-
         dma_addr = map_single(dev, ptr, size, dir);
 
-        local_irq_restore(flags);
-
         return dma_addr;
 }
 
@@ -424,25 +436,18 @@ void
 dma_unmap_single(struct device *dev, dma_addr_t dma_addr, size_t size,
                         enum dma_data_direction dir)
 {
-        unsigned long flags;
-
         dev_dbg(dev, "%s(ptr=%p,size=%d,dir=%x)\n",
                 __func__, (void *) dma_addr, size, dir);
 
         BUG_ON(dir == DMA_NONE);
 
-        local_irq_save(flags);
-
         unmap_single(dev, dma_addr, size, dir);
-
-        local_irq_restore(flags);
 }
 
 int
 dma_map_sg(struct device *dev, struct scatterlist *sg, int nents,
                 enum dma_data_direction dir)
 {
-        unsigned long flags;
         int i;
 
         dev_dbg(dev, "%s(sg=%p,nents=%d,dir=%x)\n",
@@ -450,8 +455,6 @@ dma_map_sg(struct device *dev, struct scatterlist *sg, int nents,
 
         BUG_ON(dir == DMA_NONE);
 
-        local_irq_save(flags);
-
         for (i = 0; i < nents; i++, sg++) {
                 struct page *page = sg->page;
                 unsigned int offset = sg->offset;
@@ -462,8 +465,6 @@ dma_map_sg(struct device *dev, struct scatterlist *sg, int nents,
                         map_single(dev, ptr, length, dir);
         }
 
-        local_irq_restore(flags);
-
         return nents;
 }
 
@@ -471,7 +472,6 @@ void
 dma_unmap_sg(struct device *dev, struct scatterlist *sg, int nents,
                 enum dma_data_direction dir)
 {
-        unsigned long flags;
         int i;
 
         dev_dbg(dev, "%s(sg=%p,nents=%d,dir=%x)\n",
@@ -479,55 +479,38 @@ dma_unmap_sg(struct device *dev, struct scatterlist *sg, int nents,
 
         BUG_ON(dir == DMA_NONE);
 
-        local_irq_save(flags);
-
         for (i = 0; i < nents; i++, sg++) {
                 dma_addr_t dma_addr = sg->dma_address;
                 unsigned int length = sg->length;
 
                 unmap_single(dev, dma_addr, length, dir);
         }
-
-        local_irq_restore(flags);
 }
 
 void
 dma_sync_single_for_cpu(struct device *dev, dma_addr_t dma_addr, size_t size,
                                 enum dma_data_direction dir)
 {
-        unsigned long flags;
-
         dev_dbg(dev, "%s(ptr=%p,size=%d,dir=%x)\n",
                 __func__, (void *) dma_addr, size, dir);
 
-        local_irq_save(flags);
-
         sync_single(dev, dma_addr, size, dir);
-
-        local_irq_restore(flags);
 }
 
 void
 dma_sync_single_for_device(struct device *dev, dma_addr_t dma_addr, size_t size,
                                 enum dma_data_direction dir)
 {
-        unsigned long flags;
-
         dev_dbg(dev, "%s(ptr=%p,size=%d,dir=%x)\n",
                 __func__, (void *) dma_addr, size, dir);
 
-        local_irq_save(flags);
-
         sync_single(dev, dma_addr, size, dir);
-
-        local_irq_restore(flags);
 }
 
 void
 dma_sync_sg_for_cpu(struct device *dev, struct scatterlist *sg, int nents,
                         enum dma_data_direction dir)
 {
-        unsigned long flags;
         int i;
 
         dev_dbg(dev, "%s(sg=%p,nents=%d,dir=%x)\n",
@@ -535,23 +518,18 @@ dma_sync_sg_for_cpu(struct device *dev, struct scatterlist *sg, int nents,
 
         BUG_ON(dir == DMA_NONE);
 
-        local_irq_save(flags);
-
         for (i = 0; i < nents; i++, sg++) {
                 dma_addr_t dma_addr = sg->dma_address;
                 unsigned int length = sg->length;
 
                 sync_single(dev, dma_addr, length, dir);
         }
-
-        local_irq_restore(flags);
 }
 
 void
 dma_sync_sg_for_device(struct device *dev, struct scatterlist *sg, int nents,
                         enum dma_data_direction dir)
 {
-        unsigned long flags;
         int i;
 
         dev_dbg(dev, "%s(sg=%p,nents=%d,dir=%x)\n",
@@ -559,16 +537,12 @@ dma_sync_sg_for_device(struct device *dev, struct scatterlist *sg, int nents,
 
         BUG_ON(dir == DMA_NONE);
 
-        local_irq_save(flags);
-
         for (i = 0; i < nents; i++, sg++) {
                 dma_addr_t dma_addr = sg->dma_address;
                 unsigned int length = sg->length;
 
                 sync_single(dev, dma_addr, length, dir);
         }
-
-        local_irq_restore(flags);
 }
 
 static int
@@ -622,6 +596,7 @@ dmabounce_register_dev(struct device *dev, unsigned long small_buffer_size,
 
         device_info->dev = dev;
         INIT_LIST_HEAD(&device_info->safe_buffers);
+        rwlock_init(&device_info->lock);
 
 #ifdef STATS
         device_info->total_allocs = 0;
diff --git a/arch/arm/common/uengine.c b/arch/arm/common/uengine.c
index a1310b71004e..dfca596a9a27 100644
--- a/arch/arm/common/uengine.c
+++ b/arch/arm/common/uengine.c
@@ -18,10 +18,26 @@
 #include <linux/module.h>
 #include <linux/string.h>
 #include <asm/hardware.h>
-#include <asm/arch/ixp2000-regs.h>
+#include <asm/arch/hardware.h>
 #include <asm/hardware/uengine.h>
 #include <asm/io.h>
 
+#if defined(CONFIG_ARCH_IXP2000)
+#define IXP_UENGINE_CSR_VIRT_BASE       IXP2000_UENGINE_CSR_VIRT_BASE
+#define IXP_PRODUCT_ID                  IXP2000_PRODUCT_ID
+#define IXP_MISC_CONTROL                IXP2000_MISC_CONTROL
+#define IXP_RESET1                      IXP2000_RESET1
+#else
+#if defined(CONFIG_ARCH_IXP23XX)
+#define IXP_UENGINE_CSR_VIRT_BASE       IXP23XX_UENGINE_CSR_VIRT_BASE
+#define IXP_PRODUCT_ID                  IXP23XX_PRODUCT_ID
+#define IXP_MISC_CONTROL                IXP23XX_MISC_CONTROL
+#define IXP_RESET1                      IXP23XX_RESET1
+#else
+#error unknown platform
+#endif
+#endif
+
 #define USTORE_ADDRESS                  0x000
 #define USTORE_DATA_LOWER               0x004
 #define USTORE_DATA_UPPER               0x008
@@ -43,7 +59,7 @@ u32 ixp2000_uengine_mask;
 
 static void *ixp2000_uengine_csr_area(int uengine)
 {
-        return ((void *)IXP2000_UENGINE_CSR_VIRT_BASE) + (uengine << 10);
+        return ((void *)IXP_UENGINE_CSR_VIRT_BASE) + (uengine << 10);
 }
 
 /*
@@ -91,8 +107,13 @@ EXPORT_SYMBOL(ixp2000_uengine_csr_write);
 
 void ixp2000_uengine_reset(u32 uengine_mask)
 {
-        ixp2000_reg_wrb(IXP2000_RESET1, uengine_mask & ixp2000_uengine_mask);
-        ixp2000_reg_wrb(IXP2000_RESET1, 0);
+        u32 value;
+
+        value = ixp2000_reg_read(IXP_RESET1) & ~ixp2000_uengine_mask;
+
+        uengine_mask &= ixp2000_uengine_mask;
+        ixp2000_reg_wrb(IXP_RESET1, value | uengine_mask);
+        ixp2000_reg_wrb(IXP_RESET1, value);
 }
 EXPORT_SYMBOL(ixp2000_uengine_reset);
 
@@ -235,11 +256,12 @@ static int check_ixp_type(struct ixp2000_uengine_code *c)
         u32 product_id;
         u32 rev;
 
-        product_id = ixp2000_reg_read(IXP2000_PRODUCT_ID);
+        product_id = ixp2000_reg_read(IXP_PRODUCT_ID);
         if (((product_id >> 16) & 0x1f) != 0)
                 return 0;
 
         switch ((product_id >> 8) & 0xff) {
+#ifdef CONFIG_ARCH_IXP2000
         case 0:         /* IXP2800 */
                 if (!(c->cpu_model_bitmask & 4))
                         return 0;
@@ -254,6 +276,14 @@ static int check_ixp_type(struct ixp2000_uengine_code *c)
                 if (!(c->cpu_model_bitmask & 2))
                         return 0;
                 break;
+#endif
+
+#ifdef CONFIG_ARCH_IXP23XX
+        case 4:         /* IXP23xx */
+                if (!(c->cpu_model_bitmask & 0x3f0))
+                        return 0;
+                break;
+#endif
 
         default:
                 return 0;
@@ -432,7 +462,8 @@ static int __init ixp2000_uengine_init(void)
         /*
          * Determine number of microengines present.
          */
-        switch ((ixp2000_reg_read(IXP2000_PRODUCT_ID) >> 8) & 0x1fff) {
+        switch ((ixp2000_reg_read(IXP_PRODUCT_ID) >> 8) & 0x1fff) {
+#ifdef CONFIG_ARCH_IXP2000
         case 0:         /* IXP2800 */
         case 1:         /* IXP2850 */
                 ixp2000_uengine_mask = 0x00ff00ff;
@@ -441,10 +472,17 @@ static int __init ixp2000_uengine_init(void)
         case 2:         /* IXP2400 */
                 ixp2000_uengine_mask = 0x000f000f;
                 break;
+#endif
+
+#ifdef CONFIG_ARCH_IXP23XX
+        case 4:         /* IXP23xx */
+                ixp2000_uengine_mask = (*IXP23XX_EXP_CFG_FUSE >> 8) & 0xf;
+                break;
+#endif
 
         default:
                 printk(KERN_INFO "Detected unknown IXP2000 model (%.8x)\n",
-                        (unsigned int)ixp2000_reg_read(IXP2000_PRODUCT_ID));
+                        (unsigned int)ixp2000_reg_read(IXP_PRODUCT_ID));
                 ixp2000_uengine_mask = 0x00000000;
                 break;
         }
@@ -457,15 +495,15 @@ static int __init ixp2000_uengine_init(void)
         /*
          * Synchronise timestamp counters across all microengines.
          */
-        value = ixp2000_reg_read(IXP2000_MISC_CONTROL);
-        ixp2000_reg_wrb(IXP2000_MISC_CONTROL, value & ~0x80);
+        value = ixp2000_reg_read(IXP_MISC_CONTROL);
+        ixp2000_reg_wrb(IXP_MISC_CONTROL, value & ~0x80);
         for (uengine = 0; uengine < 32; uengine++) {
                 if (ixp2000_uengine_mask & (1 << uengine)) {
                         ixp2000_uengine_csr_write(uengine, TIMESTAMP_LOW, 0);
                         ixp2000_uengine_csr_write(uengine, TIMESTAMP_HIGH, 0);
                 }
         }
-        ixp2000_reg_wrb(IXP2000_MISC_CONTROL, value | 0x80);
+        ixp2000_reg_wrb(IXP_MISC_CONTROL, value | 0x80);
 
         return 0;
 }
diff --git a/arch/arm/configs/lpd270_defconfig b/arch/arm/configs/lpd270_defconfig
new file mode 100644
index 000000000000..d08bbe59483a
--- /dev/null
+++ b/arch/arm/configs/lpd270_defconfig
@@ -0,0 +1,963 @@
+#
+# Automatically generated make config: don't edit
+# Linux kernel version: 2.6.17-git2
+# Wed Jun 21 22:20:18 2006
+#
+CONFIG_ARM=y
+CONFIG_MMU=y
+CONFIG_RWSEM_GENERIC_SPINLOCK=y
+CONFIG_GENERIC_HWEIGHT=y
+CONFIG_GENERIC_CALIBRATE_DELAY=y
+CONFIG_ARCH_MTD_XIP=y
+CONFIG_VECTORS_BASE=0xffff0000
+
+#
+# Code maturity level options
+#
+CONFIG_EXPERIMENTAL=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_RELAY is not set
+CONFIG_INITRAMFS_SOURCE=""
+CONFIG_UID16=y
+CONFIG_CC_OPTIMIZE_FOR_SIZE=y
+# 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
+CONFIG_SHMEM=y
+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 is not set
+# CONFIG_MODVERSIONS is not set
+# CONFIG_MODULE_SRCVERSION_ALL is not set
+# CONFIG_KMOD is not set
+
+#
+# Block layer
+#
+# CONFIG_BLK_DEV_IO_TRACE 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_ARCH_AAEC2000 is not set
+# CONFIG_ARCH_INTEGRATOR is not set
+# CONFIG_ARCH_REALVIEW is not set
+# CONFIG_ARCH_VERSATILE is not set
+# CONFIG_ARCH_AT91RM9200 is not set
+# CONFIG_ARCH_CLPS7500 is not set
+# CONFIG_ARCH_CLPS711X is not set
+# CONFIG_ARCH_CO285 is not set
+# CONFIG_ARCH_EBSA110 is not set
+# CONFIG_ARCH_EP93XX is not set
+# CONFIG_ARCH_FOOTBRIDGE is not set
+# CONFIG_ARCH_NETX is not set
+# CONFIG_ARCH_H720X is not set
+# CONFIG_ARCH_IMX is not set
+# CONFIG_ARCH_IOP3XX is not set
+# CONFIG_ARCH_IXP4XX is not set
+# CONFIG_ARCH_IXP2000 is not set
+# CONFIG_ARCH_IXP23XX is not set
+# CONFIG_ARCH_L7200 is not set
+# CONFIG_ARCH_PNX4008 is not set
+CONFIG_ARCH_PXA=y
+# CONFIG_ARCH_RPC is not set
+# CONFIG_ARCH_SA1100 is not set
+# CONFIG_ARCH_S3C2410 is not set
+# CONFIG_ARCH_SHARK is not set
+# CONFIG_ARCH_LH7A40X is not set
+# CONFIG_ARCH_OMAP is not set
+
+#
+# Intel PXA2xx Implementations
+#
+# CONFIG_ARCH_LUBBOCK is not set
+CONFIG_MACH_LOGICPD_PXA270=y
+# CONFIG_MACH_MAINSTONE is not set
+# CONFIG_ARCH_PXA_IDP is not set
+# CONFIG_PXA_SHARPSL is not set
+CONFIG_PXA27x=y
+CONFIG_IWMMXT=y
+
+#
+# Processor Type
+#
+CONFIG_CPU_32=y
+CONFIG_CPU_XSCALE=y
+CONFIG_CPU_32v5=y
+CONFIG_CPU_ABRT_EV5T=y
+CONFIG_CPU_CACHE_VIVT=y
+CONFIG_CPU_TLB_V4WBI=y
+
+#
+# Processor Features
+#
+# CONFIG_ARM_THUMB is not set
+CONFIG_XSCALE_PMU=y
+
+#
+# Bus support
+#
+
+#
+# PCCARD (PCMCIA/CardBus) support
+#
+# CONFIG_PCCARD is not set
+
+#
+# Kernel Features
+#
+# CONFIG_PREEMPT is not set
+# CONFIG_NO_IDLE_HZ is not set
+CONFIG_HZ=100
+# CONFIG_AEABI is not set
+# CONFIG_ARCH_DISCONTIGMEM_ENABLE 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=4096
+CONFIG_ALIGNMENT_TRAP=y
+
+#
+# Boot options
+#
+CONFIG_ZBOOT_ROM_TEXT=0x0
+CONFIG_ZBOOT_ROM_BSS=0x0
+CONFIG_CMDLINE="root=/dev/nfs ip=bootp console=ttyS0,115200 mem=64M"
+# CONFIG_XIP_KERNEL is not set
+
+#
+# Floating point emulation
+#
+
+#
+# At least one emulation must be selected
+#
+CONFIG_FPE_NWFPE=y
+# CONFIG_FPE_NWFPE_XP is not set
+# CONFIG_FPE_FASTFPE is not set
+
+#
+# Userspace binary formats
+#
+CONFIG_BINFMT_ELF=y
+# CONFIG_BINFMT_AOUT is not set
+# CONFIG_BINFMT_MISC is not set
+# CONFIG_ARTHUR is not set
+
+#
+# Power management options
+#
+# CONFIG_PM is not set
+# CONFIG_PM_LEGACY is not set
+# CONFIG_PM_DEBUG is not set
+# CONFIG_APM is not set
+
+#
+# Networking
+#
+CONFIG_NET=y
+
+#
+# Networking options
+#
+# CONFIG_NETDEBUG is not set
+# CONFIG_PACKET is not set
+CONFIG_UNIX=y
+CONFIG_XFRM=y
+# CONFIG_XFRM_USER is not set
+# CONFIG_NET_KEY is not set
+CONFIG_INET=y
+# CONFIG_IP_MULTICAST is not set
+# CONFIG_IP_ADVANCED_ROUTER is not set
+CONFIG_IP_FIB_HASH=y
+CONFIG_IP_PNP=y
+# CONFIG_IP_PNP_DHCP is not set
+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_ARPD is not set
+# CONFIG_SYN_COOKIES is not set
+# CONFIG_INET_AH is not set
+# CONFIG_INET_ESP is not set
+# CONFIG_INET_IPCOMP is not set
+# CONFIG_INET_XFRM_TUNNEL is not set
+# CONFIG_INET_TUNNEL is not set
+CONFIG_INET_XFRM_MODE_TRANSPORT=y
+CONFIG_INET_XFRM_MODE_TUNNEL=y
+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_INET6_XFRM_TUNNEL is not set
+# CONFIG_INET6_TUNNEL is not set
+# CONFIG_NETWORK_SECMARK 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
+
+#
+# TIPC Configuration (EXPERIMENTAL)
+#
+# CONFIG_TIPC 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
+# CONFIG_DEBUG_DRIVER is not set
+
+#
+# Connector - unified userspace <-> kernelspace linker
+#
+# CONFIG_CONNECTOR is not set
+
+#
+# Memory Technology Devices (MTD)
+#
+CONFIG_MTD=y
+# CONFIG_MTD_DEBUG is not set
+# CONFIG_MTD_CONCAT is not set
+CONFIG_MTD_PARTITIONS=y
+CONFIG_MTD_REDBOOT_PARTS=y
+CONFIG_MTD_REDBOOT_DIRECTORY_BLOCK=-1
+# CONFIG_MTD_REDBOOT_PARTS_UNALLOCATED is not set
+# CONFIG_MTD_REDBOOT_PARTS_READONLY is not set
+# CONFIG_MTD_CMDLINE_PARTS is not set
+# CONFIG_MTD_AFS_PARTS is not set
+
+#
+# User Modules And Translation Layers
+#
+CONFIG_MTD_CHAR=y
+CONFIG_MTD_BLOCK=y
+# CONFIG_FTL is not set
+# CONFIG_NFTL is not set
+# CONFIG_INFTL is not set
+# CONFIG_RFD_FTL is not set
+
+#
+# RAM/ROM/Flash chip drivers
+#
+CONFIG_MTD_CFI=y
+# CONFIG_MTD_JEDECPROBE is not set
+CONFIG_MTD_GEN_PROBE=y
+CONFIG_MTD_CFI_ADV_OPTIONS=y
+CONFIG_MTD_CFI_NOSWAP=y
+# CONFIG_MTD_CFI_BE_BYTE_SWAP is not set
+# CONFIG_MTD_CFI_LE_BYTE_SWAP is not set
+CONFIG_MTD_CFI_GEOMETRY=y
+CONFIG_MTD_MAP_BANK_WIDTH_1=y
+CONFIG_MTD_MAP_BANK_WIDTH_2=y
+CONFIG_MTD_MAP_BANK_WIDTH_4=y
+# CONFIG_MTD_MAP_BANK_WIDTH_8 is not set
+# CONFIG_MTD_MAP_BANK_WIDTH_16 is not set
+# CONFIG_MTD_MAP_BANK_WIDTH_32 is not set
+# CONFIG_MTD_CFI_I1 is not set
+CONFIG_MTD_CFI_I2=y
+# CONFIG_MTD_CFI_I4 is not set
+# CONFIG_MTD_CFI_I8 is not set
+# CONFIG_MTD_OTP is not set
+CONFIG_MTD_CFI_INTELEXT=y
+# CONFIG_MTD_CFI_AMDSTD is not set
+# CONFIG_MTD_CFI_STAA is not set
+CONFIG_MTD_CFI_UTIL=y
+# CONFIG_MTD_RAM is not set
+# CONFIG_MTD_ROM is not set
+# CONFIG_MTD_ABSENT is not set
+# CONFIG_MTD_OBSOLETE_CHIPS is not set
+# CONFIG_MTD_XIP is not set
+
+#
+# Mapping drivers for chip access
+#
+# CONFIG_MTD_COMPLEX_MAPPINGS is not set
+# CONFIG_MTD_PHYSMAP is not set
+# CONFIG_MTD_ARM_INTEGRATOR is not set
+# CONFIG_MTD_SHARP_SL is not set
+# CONFIG_MTD_PLATRAM is not set
+
+#
+# Self-contained MTD device drivers
+#
+# CONFIG_MTD_SLRAM is not set
+# CONFIG_MTD_PHRAM is not set
+# CONFIG_MTD_MTDRAM is not set
+# CONFIG_MTD_BLOCK2MTD is not set
+
+#
+# Disk-On-Chip Device Drivers
+#
+# CONFIG_MTD_DOC2000 is not set
+# CONFIG_MTD_DOC2001 is not set
+# CONFIG_MTD_DOC2001PLUS is not set
+
+#
+# NAND Flash Device Drivers
+#
+# CONFIG_MTD_NAND is not set
+
+#
+# OneNAND Flash Device Drivers
+#
+# CONFIG_MTD_ONENAND is not set
+
+#
+# Parallel port support
+#
+# CONFIG_PARPORT is not set
+
+#
+# Plug and Play support
+#
+
+#
+# Block devices
+#
+# CONFIG_BLK_DEV_COW_COMMON is not set
+# CONFIG_BLK_DEV_LOOP is not set
+# CONFIG_BLK_DEV_NBD is not set
+# CONFIG_BLK_DEV_RAM is not set
+# CONFIG_BLK_DEV_INITRD is not set
+# CONFIG_CDROM_PKTCDVD is not set
+# CONFIG_ATA_OVER_ETH is not set
+
+#
+# ATA/ATAPI/MFM/RLL support
+#
+CONFIG_IDE=y
+CONFIG_BLK_DEV_IDE=y
+
+#
+# Please see Documentation/ide.txt for help/info on IDE drives
+#
+# CONFIG_BLK_DEV_IDE_SATA is not set
+CONFIG_BLK_DEV_IDEDISK=y
+# CONFIG_IDEDISK_MULTI_MODE is not set
+# CONFIG_BLK_DEV_IDECD is not set
+# CONFIG_BLK_DEV_IDETAPE is not set
+# CONFIG_BLK_DEV_IDEFLOPPY is not set
+# CONFIG_IDE_TASK_IOCTL is not set
+
+#
+# IDE chipset support/bugfixes
+#
+# CONFIG_IDE_GENERIC is not set
+# CONFIG_IDE_ARM is not set
+# CONFIG_BLK_DEV_IDEDMA is not set
+# CONFIG_IDEDMA_AUTO is not set
+# CONFIG_BLK_DEV_HD 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
+#
+
+#
+# I2O device support
+#
+
+#
+# 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
+
+#
+# PHY device support
+#
+# CONFIG_PHYLIB is not set
+
+#
+# Ethernet (10 or 100Mbit)
+#
+CONFIG_NET_ETHERNET=y
+CONFIG_MII=y
+CONFIG_SMC91X=y
+# CONFIG_DM9000 is not set
+# CONFIG_SMC911X is not set
+
+#
+# Ethernet (1000 Mbit)
+#
+
+#
+# Ethernet (10000 Mbit)
+#
+
+#
+# Token Ring devices
+#
+
+#
+# Wireless LAN (non-hamradio)
+#
+# CONFIG_NET_RADIO is not set
+
+#
+# Wan interfaces
+#
+# CONFIG_WAN 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
+
+#
+# Input device support
+#
+CONFIG_INPUT=y
+
+#
+# Userland interfaces
+#
+CONFIG_INPUT_MOUSEDEV=y
+CONFIG_INPUT_MOUSEDEV_PSAUX=y
+CONFIG_INPUT_MOUSEDEV_SCREEN_X=1024
+CONFIG_INPUT_MOUSEDEV_SCREEN_Y=768
+# CONFIG_INPUT_JOYDEV is not set
+# CONFIG_INPUT_TSDEV is not set
+CONFIG_INPUT_EVDEV=y
+# CONFIG_INPUT_EVBUG is not set
+
+#
+# Input Device Drivers
+#
+CONFIG_INPUT_KEYBOARD=y
+CONFIG_KEYBOARD_ATKBD=y
+# CONFIG_KEYBOARD_SUNKBD is not set
+# CONFIG_KEYBOARD_LKKBD is not set
+# CONFIG_KEYBOARD_XTKBD is not set
+# CONFIG_KEYBOARD_NEWTON 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=y
+# CONFIG_SERIO_SERPORT is not set
+CONFIG_SERIO_LIBPS2=y
+# CONFIG_SERIO_RAW is not set
+# CONFIG_GAMEPORT is not set
+
+#
+# Character devices
+#
+CONFIG_VT=y
+CONFIG_VT_CONSOLE=y
+CONFIG_HW_CONSOLE=y
+# CONFIG_SERIAL_NONSTANDARD is not set
+
+#
+# Serial drivers
+#
+# CONFIG_SERIAL_8250 is not set
+
+#
+# Non-8250 serial port support
+#
+CONFIG_SERIAL_PXA=y
+CONFIG_SERIAL_PXA_CONSOLE=y
+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 is not set
+# CONFIG_NVRAM is not set
+# CONFIG_DTLK is not set
+# CONFIG_R3964 is not set
+
+#
+# Ftape, the floppy tape device driver
+#
+# 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
+
+#
+# SPI support
+#
+# CONFIG_SPI is not set
+# CONFIG_SPI_MASTER 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_F71805F is not set
+# CONFIG_HWMON_DEBUG_CHIP is not set
+
+#
+# Misc devices
+#
+
+#
+# LED devices
+#
+# CONFIG_NEW_LEDS is not set
+
+#
+# LED drivers
+#
+
+#
+# LED Triggers
+#
+
+#
+# Multimedia devices
+#
+# CONFIG_VIDEO_DEV is not set
+CONFIG_VIDEO_V4L2=y
+
+#
+# Digital Video Broadcasting Devices
+#
+# CONFIG_DVB is not set
+
+#
+# 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_FIRMWARE_EDID=y
+# CONFIG_FB_MODE_HELPERS is not set
+# CONFIG_FB_TILEBLITTING is not set
+# CONFIG_FB_S1D13XXX is not set
+CONFIG_FB_PXA=y
+# CONFIG_FB_PXA_PARAMETERS is not set
+# CONFIG_FB_VIRTUAL is not set
+
+#
+# Console display driver support
+#
+# CONFIG_VGA_CONSOLE is not set
+CONFIG_DUMMY_CONSOLE=y
+CONFIG_FRAMEBUFFER_CONSOLE=y
+# CONFIG_FRAMEBUFFER_CONSOLE_ROTATION is not set
+# CONFIG_FONTS is not set
+CONFIG_FONT_8x8=y
+CONFIG_FONT_8x16=y
+
+#
+# Logo configuration
+#
+CONFIG_LOGO=y
+CONFIG_LOGO_LINUX_MONO=y
+CONFIG_LOGO_LINUX_VGA16=y
+CONFIG_LOGO_LINUX_CLUT224=y
+# CONFIG_BACKLIGHT_LCD_SUPPORT is not set
+
+#
+# Sound
+#
+CONFIG_SOUND=y
+
+#
+# Advanced Linux Sound Architecture
+#
+CONFIG_SND=y
+CONFIG_SND_TIMER=y
+CONFIG_SND_PCM=y
+# CONFIG_SND_SEQUENCER is not set
+# CONFIG_SND_MIXER_OSS is not set
+# CONFIG_SND_PCM_OSS is not set
+# CONFIG_SND_DYNAMIC_MINORS is not set
+# CONFIG_SND_SUPPORT_OLD_API is not set
+CONFIG_SND_VERBOSE_PROCFS=y
+# CONFIG_SND_VERBOSE_PRINTK is not set
+# CONFIG_SND_DEBUG is not set
+
+#
+# Generic devices
+#
+CONFIG_SND_AC97_CODEC=y
+CONFIG_SND_AC97_BUS=y
+# CONFIG_SND_DUMMY is not set
+# CONFIG_SND_MTPAV is not set
+# CONFIG_SND_SERIAL_U16550 is not set
+# CONFIG_SND_MPU401 is not set
+
+#
+# ALSA ARM devices
+#
+CONFIG_SND_PXA2XX_PCM=y
+CONFIG_SND_PXA2XX_AC97=y
+
+#
+# Open Sound System
+#
+# CONFIG_SOUND_PRIME is not set
+
+#
+# USB support
+#
+CONFIG_USB_ARCH_HAS_HCD=y
+CONFIG_USB_ARCH_HAS_OHCI=y
+# CONFIG_USB_ARCH_HAS_EHCI is not set
+# 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
+
+#
+# Real Time Clock
+#
+CONFIG_RTC_LIB=y
+# CONFIG_RTC_CLASS is not set
+
+#
+# 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_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_INOTIFY_USER=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_FAT_FS=y
+CONFIG_MSDOS_FS=y
+# CONFIG_VFAT_FS is not set
+CONFIG_FAT_DEFAULT_CODEPAGE=437
+# CONFIG_NTFS_FS is not set
+
+#
+# Pseudo filesystems
+#
+CONFIG_PROC_FS=y
+CONFIG_SYSFS=y
+# CONFIG_TMPFS is not set
+# CONFIG_HUGETLB_PAGE is not set
+CONFIG_RAMFS=y
+# 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_JFFS_FS is not set
+CONFIG_JFFS2_FS=y
+CONFIG_JFFS2_FS_DEBUG=0
+CONFIG_JFFS2_FS_WRITEBUFFER=y
+# CONFIG_JFFS2_SUMMARY is not set
+# CONFIG_JFFS2_COMPRESSION_OPTIONS is not set
+CONFIG_JFFS2_ZLIB=y
+CONFIG_JFFS2_RTIME=y
+# CONFIG_JFFS2_RUBIN 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 is not set
+# CONFIG_NFS_V4 is not set
+# CONFIG_NFS_DIRECTIO is not set
+# CONFIG_NFSD is not set
+CONFIG_ROOT_NFS=y
+CONFIG_LOCKD=y
+CONFIG_NFS_COMMON=y
+CONFIG_SUNRPC=y
+# CONFIG_RPCSEC_GSS_KRB5 is not set
+# 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 is not set
+CONFIG_MSDOS_PARTITION=y
+
+#
+# Native Language Support
+#
+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=y
+# 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
+#
+# CONFIG_PROFILING is not set
+
+#
+# Kernel hacking
+#
+# CONFIG_PRINTK_TIME is not set
+CONFIG_MAGIC_SYSRQ=y
+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
+CONFIG_DEBUG_BUGVERBOSE=y
+CONFIG_DEBUG_INFO=y
+# CONFIG_DEBUG_FS is not set
+# CONFIG_DEBUG_VM is not set
+CONFIG_FRAME_POINTER=y
+# CONFIG_UNWIND_INFO is not set
+CONFIG_FORCED_INLINING=y
+# CONFIG_RCU_TORTURE_TEST is not set
+CONFIG_DEBUG_USER=y
+# CONFIG_DEBUG_WAITQ is not set
+CONFIG_DEBUG_ERRORS=y
+CONFIG_DEBUG_LL=y
+# CONFIG_DEBUG_ICEDCC is not set
+
+#
+# Security options
+#
+# CONFIG_KEYS is not set
+# CONFIG_SECURITY is not set
+
+#
+# Cryptographic options
+#
+# CONFIG_CRYPTO is not set
+
+#
+# Hardware crypto devices
+#
+
+#
+# Library routines
+#
+# CONFIG_CRC_CCITT is not set
+# CONFIG_CRC16 is not set
+CONFIG_CRC32=y
+# CONFIG_LIBCRC32C is not set
+CONFIG_ZLIB_INFLATE=y
+CONFIG_ZLIB_DEFLATE=y
diff --git a/arch/arm/kernel/entry-armv.S b/arch/arm/kernel/entry-armv.S
index ab8e600c18c8..86c92523a346 100644
--- a/arch/arm/kernel/entry-armv.S
+++ b/arch/arm/kernel/entry-armv.S
@@ -20,6 +20,7 @@
 #include <asm/glue.h>
 #include <asm/vfpmacros.h>
 #include <asm/arch/entry-macro.S>
+#include <asm/thread_notify.h>
 
 #include "entry-header.S"
 
@@ -560,10 +561,8 @@ 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]!
+#ifdef CONFIG_MMU
+        ldr     r6, [r2, #TI_CPU_DOMAIN]
 #endif
 #if __LINUX_ARM_ARCH__ >= 6
 #ifdef CONFIG_CPU_32v6K
@@ -585,21 +584,20 @@ ENTRY(__switch_to)
 #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.
-        VFPFMRX r4, FPEXC
-        bic     r4, r4, #FPEXC_ENABLE
-        VFPFMXR FPEXC, r4
-#endif
 #if defined(CONFIG_IWMMXT)
         bl      iwmmxt_task_switch
 #elif defined(CONFIG_CPU_XSCALE)
-        add     r4, r2, #40                     @ cpu_context_save->extra
+        add     r4, r2, #TI_CPU_DOMAIN + 40     @ cpu_context_save->extra
         ldmib   r4, {r4, r5}
         mar     acc0, r4, r5
 #endif
-        ldmib   r2, {r4 - sl, fp, sp, pc}       @ Load all regs saved previously
+        mov     r5, r0
+        add     r4, r2, #TI_CPU_SAVE
+        ldr     r0, =thread_notify_head
+        mov     r1, #THREAD_NOTIFY_SWITCH
+        bl      atomic_notifier_call_chain
+        mov     r0, r5
+        ldmia   r4, {r4 - sl, fp, sp, pc}       @ Load all regs saved previously
 
         __INIT
 
diff --git a/arch/arm/kernel/irq.c b/arch/arm/kernel/irq.c
index bcc19fbb32df..ec20f8935e8b 100644
--- a/arch/arm/kernel/irq.c
+++ b/arch/arm/kernel/irq.c
@@ -52,7 +52,7 @@
  */
 #define MAX_IRQ_CNT     100000
 
-static int noirqdebug;
+static int noirqdebug __read_mostly;
 static volatile unsigned long irq_err_count;
 static DEFINE_SPINLOCK(irq_controller_lock);
 static LIST_HEAD(irq_pending);
@@ -81,7 +81,7 @@ irqreturn_t no_action(int irq, void *dev_id, struct pt_regs *regs)
 
 void do_bad_IRQ(unsigned int irq, struct irqdesc *desc, struct pt_regs *regs)
 {
-        irq_err_count += 1;
+        irq_err_count++;
         printk(KERN_ERR "IRQ: spurious interrupt %d\n", irq);
 }
 
diff --git a/arch/arm/kernel/iwmmxt.S b/arch/arm/kernel/iwmmxt.S
index 24c7b0477a09..af9e0ae952d5 100644
--- a/arch/arm/kernel/iwmmxt.S
+++ b/arch/arm/kernel/iwmmxt.S
@@ -285,7 +285,7 @@ ENTRY(iwmmxt_task_switch)
         bne     1f                              @ yes: block them for next task
 
         ldr     r5, =concan_owner
-        add     r6, r2, #(TI_IWMMXT_STATE - TI_CPU_DOMAIN) @ get next task Concan save area
+        add     r6, r2, #TI_IWMMXT_STATE        @ get next task Concan save area
         ldr     r5, [r5]                        @ get current Concan owner
         teq     r5, r6                          @ next task owns it?
         movne   pc, lr                          @ no: leave Concan disabled
diff --git a/arch/arm/kernel/process.c b/arch/arm/kernel/process.c
index 17c38dbf2f3c..e1c77ee885a7 100644
--- a/arch/arm/kernel/process.c
+++ b/arch/arm/kernel/process.c
@@ -33,6 +33,7 @@
 #include <asm/leds.h>
 #include <asm/processor.h>
 #include <asm/system.h>
+#include <asm/thread_notify.h>
 #include <asm/uaccess.h>
 #include <asm/mach/time.h>
 
@@ -338,13 +339,9 @@ void exit_thread(void)
 {
 }
 
-static void default_fp_init(union fp_state *fp)
-{
-        memset(fp, 0, sizeof(union fp_state));
-}
+ATOMIC_NOTIFIER_HEAD(thread_notify_head);
 
-void (*fp_init)(union fp_state *) = default_fp_init;
-EXPORT_SYMBOL(fp_init);
+EXPORT_SYMBOL_GPL(thread_notify_head);
 
 void flush_thread(void)
 {
@@ -353,22 +350,21 @@ void flush_thread(void)
 
         memset(thread->used_cp, 0, sizeof(thread->used_cp));
         memset(&tsk->thread.debug, 0, sizeof(struct debug_info));
+        memset(&thread->fpstate, 0, sizeof(union fp_state));
+
+        thread_notify(THREAD_NOTIFY_FLUSH, thread);
 #if defined(CONFIG_IWMMXT)
         iwmmxt_task_release(thread);
 #endif
-        fp_init(&thread->fpstate);
-#if defined(CONFIG_VFP)
-        vfp_flush_thread(&thread->vfpstate);
-#endif
 }
 
 void release_thread(struct task_struct *dead_task)
 {
-#if defined(CONFIG_VFP)
-        vfp_release_thread(&task_thread_info(dead_task)->vfpstate);
-#endif
+        struct thread_info *thread = task_thread_info(dead_task);
+
+        thread_notify(THREAD_NOTIFY_RELEASE, thread);
 #if defined(CONFIG_IWMMXT)
-        iwmmxt_task_release(task_thread_info(dead_task));
+        iwmmxt_task_release(thread);
 #endif
 }
 
diff --git a/arch/arm/kernel/signal.c b/arch/arm/kernel/signal.c
index a0cd0a90a10d..f094277485c8 100644
--- a/arch/arm/kernel/signal.c
+++ b/arch/arm/kernel/signal.c
@@ -665,17 +665,33 @@ static int do_signal(sigset_t *oldset, struct pt_regs *regs, int syscall)
         if (syscall) {
                 if (regs->ARM_r0 == -ERESTART_RESTARTBLOCK) {
                         if (thumb_mode(regs)) {
-                                regs->ARM_r7 = __NR_restart_syscall;
+                                regs->ARM_r7 = __NR_restart_syscall - __NR_SYSCALL_BASE;
                                 regs->ARM_pc -= 2;
                         } else {
+#if defined(CONFIG_AEABI) && !defined(CONFIG_OABI_COMPAT)
+                                regs->ARM_r7 = __NR_restart_syscall;
+                                regs->ARM_pc -= 4;
+#else
                                 u32 __user *usp;
+                                u32 swival = __NR_restart_syscall;
 
                                 regs->ARM_sp -= 12;
                                 usp = (u32 __user *)regs->ARM_sp;
 
+                                /*
+                                 * Either we supports OABI only, or we have
+                                 * EABI with the OABI compat layer enabled.
+                                 * In the later case we don't know if user
+                                 * space is EABI or not, and if not we must
+                                 * not clobber r7.  Always using the OABI
+                                 * syscall solves that issue and works for
+                                 * all those cases.
+                                 */
+                                swival = swival - __NR_SYSCALL_BASE + __NR_OABI_SYSCALL_BASE;
+
                                 put_user(regs->ARM_pc, &usp[0]);
                                 /* swi __NR_restart_syscall */
-                                put_user(0xef000000 | __NR_restart_syscall, &usp[1]);
+                                put_user(0xef000000 | swival, &usp[1]);
                                 /* ldr  pc, [sp], #12 */
                                 put_user(0xe49df00c, &usp[2]);
 
@@ -683,6 +699,7 @@ static int do_signal(sigset_t *oldset, struct pt_regs *regs, int syscall)
                                                    (unsigned long)(usp + 3));
 
                                 regs->ARM_pc = regs->ARM_sp + 4;
+#endif
                         }
                 }
                 if (regs->ARM_r0 == -ERESTARTNOHAND ||
diff --git a/arch/arm/mach-ep93xx/core.c b/arch/arm/mach-ep93xx/core.c
index dcd417625389..bf6bd71bdd08 100644
--- a/arch/arm/mach-ep93xx/core.c
+++ b/arch/arm/mach-ep93xx/core.c
@@ -103,7 +103,8 @@ static int ep93xx_timer_interrupt(int irq, void *dev_id, struct pt_regs *regs)
         write_seqlock(&xtime_lock);
 
         __raw_writel(1, EP93XX_TIMER1_CLEAR);
-        while (__raw_readl(EP93XX_TIMER4_VALUE_LOW) - last_jiffy_time
+        while ((signed long)
+                (__raw_readl(EP93XX_TIMER4_VALUE_LOW) - last_jiffy_time)
                                                 >= TIMER4_TICKS_PER_JIFFY) {
                 last_jiffy_time += TIMER4_TICKS_PER_JIFFY;
                 timer_tick(regs);
@@ -124,7 +125,7 @@ static void __init ep93xx_timer_init(void)
 {
         /* Enable periodic HZ timer.  */
         __raw_writel(0x48, EP93XX_TIMER1_CONTROL);
-        __raw_writel((508000 / HZ) - 1, EP93XX_TIMER1_LOAD);
+        __raw_writel((508469 / HZ) - 1, EP93XX_TIMER1_LOAD);
         __raw_writel(0xc8, EP93XX_TIMER1_CONTROL);
 
         /* Enable lost jiffy timer.  */
diff --git a/arch/arm/mach-ep93xx/gesbc9312.c b/arch/arm/mach-ep93xx/gesbc9312.c
index d18fcb1a2f1b..47cc6c8b7c79 100644
--- a/arch/arm/mach-ep93xx/gesbc9312.c
+++ b/arch/arm/mach-ep93xx/gesbc9312.c
@@ -16,16 +16,38 @@
 #include <linux/mm.h>
 #include <linux/sched.h>
 #include <linux/interrupt.h>
+#include <linux/ioport.h>
 #include <linux/mtd/physmap.h>
+#include <linux/platform_device.h>
 #include <asm/io.h>
 #include <asm/hardware.h>
 #include <asm/mach-types.h>
 #include <asm/mach/arch.h>
 
+static struct physmap_flash_data gesbc9312_flash_data = {
+        .width          = 4,
+};
+
+static struct resource gesbc9312_flash_resource = {
+        .start          = 0x60000000,
+        .end            = 0x60800000,
+        .flags          = IORESOURCE_MEM,
+};
+
+static struct platform_device gesbc9312_flash = {
+        .name           = "physmap-flash",
+        .id             = 0,
+        .dev            = {
+                .platform_data  = &gesbc9312_flash_data,
+        },
+        .num_resources  = 1,
+        .resource       = &gesbc9312_flash_resource,
+};
+
 static void __init gesbc9312_init_machine(void)
 {
         ep93xx_init_devices();
-        physmap_configure(0x60000000, 0x00800000, 4, NULL);
+        platform_device_register(&gesbc9312_flash);
 }
 
 MACHINE_START(GESBC9312, "Glomation GESBC-9312-sx")
diff --git a/arch/arm/mach-ep93xx/ts72xx.c b/arch/arm/mach-ep93xx/ts72xx.c
index e24566b88a78..6e5a56cd5ae8 100644
--- a/arch/arm/mach-ep93xx/ts72xx.c
+++ b/arch/arm/mach-ep93xx/ts72xx.c
@@ -16,6 +16,7 @@
 #include <linux/mm.h>
 #include <linux/sched.h>
 #include <linux/interrupt.h>
+#include <linux/ioport.h>
 #include <linux/mtd/physmap.h>
 #include <linux/platform_device.h>
 #include <linux/m48t86.h>
@@ -111,6 +112,26 @@ static void __init ts72xx_map_io(void)
         }
 }
 
+static struct physmap_flash_data ts72xx_flash_data = {
+        .width          = 1,
+};
+
+static struct resource ts72xx_flash_resource = {
+        .start          = TS72XX_NOR_PHYS_BASE,
+        .end            = TS72XX_NOR_PHYS_BASE + 0x01000000,
+        .flags          = IORESOURCE_MEM,
+};
+
+static struct platform_device ts72xx_flash = {
+        .name           = "physmap-flash",
+        .id             = 0,
+        .dev            = {
+                .platform_data  = &ts72xx_flash_data,
+        },
+        .num_resources  = 1,
+        .resource       = &ts72xx_flash_resource,
+};
+
 static unsigned char ts72xx_rtc_readbyte(unsigned long addr)
 {
         __raw_writeb(addr, TS72XX_RTC_INDEX_VIRT_BASE);
@@ -141,7 +162,7 @@ static void __init ts72xx_init_machine(void)
 {
         ep93xx_init_devices();
         if (board_is_ts7200())
-                physmap_configure(TS72XX_NOR_PHYS_BASE, 0x01000000, 1, NULL);
+                platform_device_register(&ts72xx_flash);
         platform_device_register(&ts72xx_rtc_device);
 }
 
diff --git a/arch/arm/mach-imx/dma.c b/arch/arm/mach-imx/dma.c
index 4ca51dcf13ac..36578871ecc8 100644
--- a/arch/arm/mach-imx/dma.c
+++ b/arch/arm/mach-imx/dma.c
@@ -15,6 +15,9 @@
  *             Changed to support scatter gather DMA
  *             by taking Russell's code from RiscPC
  *
+ *  2006-05-31 Pavel Pisa <pisa@cmp.felk.cvut.cz>
+ *             Corrected error handling code.
+ *
  */
 
 #undef DEBUG
@@ -277,7 +280,7 @@ imx_dma_setup_sg(imx_dmach_t dma_ch,
 int
 imx_dma_setup_handlers(imx_dmach_t dma_ch,
                        void (*irq_handler) (int, void *, struct pt_regs *),
-                       void (*err_handler) (int, void *, struct pt_regs *),
+                       void (*err_handler) (int, void *, struct pt_regs *, int),
                        void *data)
 {
         struct imx_dma_channel *imxdma = &imx_dma_channels[dma_ch];
@@ -463,43 +466,53 @@ static irqreturn_t dma_err_handler(int irq, void *dev_id, struct pt_regs *regs)
         int i, disr = DISR;
         struct imx_dma_channel *channel;
         unsigned int err_mask = DBTOSR | DRTOSR | DSESR | DBOSR;
+        int errcode;
 
-        DISR = disr;
+        DISR = disr & err_mask;
         for (i = 0; i < IMX_DMA_CHANNELS; i++) {
-                channel = &imx_dma_channels[i];
-
-                if ((err_mask & 1 << i) && channel->name
-                    && channel->err_handler) {
-                        channel->err_handler(i, channel->data, regs);
+                if(!(err_mask & (1 << i)))
                         continue;
-                }
-
-                imx_dma_channels[i].sg = NULL;
+                channel = &imx_dma_channels[i];
+                errcode = 0;
 
                 if (DBTOSR & (1 << i)) {
-                        printk(KERN_WARNING
-                               "Burst timeout on channel %d (%s)\n",
-                               i, channel->name);
-                        DBTOSR |= (1 << i);
+                        DBTOSR = (1 << i);
+                        errcode |= IMX_DMA_ERR_BURST;
                 }
                 if (DRTOSR & (1 << i)) {
-                        printk(KERN_WARNING
-                               "Request timeout on channel %d (%s)\n",
-                               i, channel->name);
-                        DRTOSR |= (1 << i);
+                        DRTOSR = (1 << i);
+                        errcode |= IMX_DMA_ERR_REQUEST;
                 }
                 if (DSESR & (1 << i)) {
-                        printk(KERN_WARNING
-                               "Transfer timeout on channel %d (%s)\n",
-                               i, channel->name);
-                        DSESR |= (1 << i);
+                        DSESR = (1 << i);
+                        errcode |= IMX_DMA_ERR_TRANSFER;
                 }
                 if (DBOSR & (1 << i)) {
-                        printk(KERN_WARNING
-                               "Buffer overflow timeout on channel %d (%s)\n",
-                               i, channel->name);
-                        DBOSR |= (1 << i);
+                        DBOSR = (1 << i);
+                        errcode |= IMX_DMA_ERR_BUFFER;
                 }
+
+                /*
+                 * The cleaning of @sg field would be questionable
+                 * there, because its value can help to compute
+                 * remaining/transfered bytes count in the handler
+                 */
+                /*imx_dma_channels[i].sg = NULL;*/
+
+                if (channel->name && channel->err_handler) {
+                        channel->err_handler(i, channel->data, regs, errcode);
+                        continue;
+                }
+
+                imx_dma_channels[i].sg = NULL;
+
+                printk(KERN_WARNING
+                       "DMA timeout on channel %d (%s) -%s%s%s%s\n",
+                       i, channel->name,
+                       errcode&IMX_DMA_ERR_BURST?    " burst":"",
+                       errcode&IMX_DMA_ERR_REQUEST?  " request":"",
+                       errcode&IMX_DMA_ERR_TRANSFER? " transfer":"",
+                       errcode&IMX_DMA_ERR_BUFFER?   " buffer":"");
         }
         return IRQ_HANDLED;
 }
diff --git a/arch/arm/mach-ixp2000/core.c b/arch/arm/mach-ixp2000/core.c
index 6e8d504aca55..186f632035b8 100644
--- a/arch/arm/mach-ixp2000/core.c
+++ b/arch/arm/mach-ixp2000/core.c
@@ -211,7 +211,8 @@ static int ixp2000_timer_interrupt(int irq, void *dev_id, struct pt_regs *regs)
         /* clear timer 1 */
         ixp2000_reg_wrb(IXP2000_T1_CLR, 1);
 
-        while ((next_jiffy_time - *missing_jiffy_timer_csr) > ticks_per_jiffy) {
+        while ((signed long)(next_jiffy_time - *missing_jiffy_timer_csr)
+                                                        >= ticks_per_jiffy) {
                 timer_tick(regs);
                 next_jiffy_time -= ticks_per_jiffy;
         }
diff --git a/arch/arm/mach-ixp23xx/core.c b/arch/arm/mach-ixp23xx/core.c
index affd1d5d7440..051e3d70026e 100644
--- a/arch/arm/mach-ixp23xx/core.c
+++ b/arch/arm/mach-ixp23xx/core.c
@@ -334,7 +334,7 @@ void __init ixp23xx_init_irq(void)
 /*************************************************************************
  * Timer-tick functions for IXP23xx
  *************************************************************************/
-#define CLOCK_TICKS_PER_USEC    CLOCK_TICK_RATE / (USEC_PER_SEC)
+#define CLOCK_TICKS_PER_USEC    (CLOCK_TICK_RATE / USEC_PER_SEC)
 
 static unsigned long next_jiffy_time;
 
@@ -353,7 +353,7 @@ ixp23xx_timer_interrupt(int irq, void *dev_id, struct pt_regs *regs)
 {
         /* Clear Pending Interrupt by writing '1' to it */
         *IXP23XX_TIMER_STATUS = IXP23XX_TIMER1_INT_PEND;
-        while ((*IXP23XX_TIMER_CONT - next_jiffy_time) > LATCH) {
+        while ((signed long)(*IXP23XX_TIMER_CONT - next_jiffy_time) >= LATCH) {
                 timer_tick(regs);
                 next_jiffy_time += LATCH;
         }
@@ -439,5 +439,6 @@ static struct platform_device *ixp23xx_devices[] __initdata = {
 
 void __init ixp23xx_sys_init(void)
 {
+        *IXP23XX_EXP_UNIT_FUSE |= 0xf;
         platform_add_devices(ixp23xx_devices, ARRAY_SIZE(ixp23xx_devices));
 }
diff --git a/arch/arm/mach-ixp23xx/espresso.c b/arch/arm/mach-ixp23xx/espresso.c
index bf688c128630..dc5e489c70bc 100644
--- a/arch/arm/mach-ixp23xx/espresso.c
+++ b/arch/arm/mach-ixp23xx/espresso.c
@@ -53,9 +53,29 @@ static int __init espresso_pci_init(void)
 };
 subsys_initcall(espresso_pci_init);
 
+static struct physmap_flash_data espresso_flash_data = {
+        .width          = 2,
+};
+
+static struct resource espresso_flash_resource = {
+        .start          = 0x90000000,
+        .end            = 0x92000000,
+        .flags          = IORESOURCE_MEM,
+};
+
+static struct platform_device espresso_flash = {
+        .name           = "physmap-flash",
+        .id             = 0,
+        .dev            = {
+                .platform_data  = &espresso_flash_data,
+        },
+        .num_resources  = 1,
+        .resource       = &espresso_flash_resource,
+};
+
 static void __init espresso_init(void)
 {
-        physmap_configure(0x90000000, 0x02000000, 2, NULL);
+        platform_device_register(&espresso_flash);
 
         /*
          * Mark flash as writeable.
diff --git a/arch/arm/mach-ixp23xx/ixdp2351.c b/arch/arm/mach-ixp23xx/ixdp2351.c
index 00146c35daac..535b334ee045 100644
--- a/arch/arm/mach-ixp23xx/ixdp2351.c
+++ b/arch/arm/mach-ixp23xx/ixdp2351.c
@@ -298,9 +298,29 @@ static void __init ixdp2351_map_io(void)
         iotable_init(ixdp2351_io_desc, ARRAY_SIZE(ixdp2351_io_desc));
 }
 
+static struct physmap_flash_data ixdp2351_flash_data = {
+        .width          = 1,
+};
+
+static struct resource ixdp2351_flash_resource = {
+        .start          = 0x90000000,
+        .end            = 0x94000000,
+        .flags          = IORESOURCE_MEM,
+};
+
+static struct platform_device ixdp2351_flash = {
+        .name           = "physmap-flash",
+        .id             = 0,
+        .dev            = {
+                .platform_data  = &ixdp2351_flash_data,
+        },
+        .num_resources  = 1,
+        .resource       = &ixdp2351_flash_resource,
+};
+
 static void __init ixdp2351_init(void)
 {
-        physmap_configure(0x90000000, 0x04000000, 1, NULL);
+        platform_device_register(&ixdp2351_flash);
 
         /*
          * Mark flash as writeable
diff --git a/arch/arm/mach-ixp23xx/roadrunner.c b/arch/arm/mach-ixp23xx/roadrunner.c
index 43c14e740794..b9f5d13fcfe1 100644
--- a/arch/arm/mach-ixp23xx/roadrunner.c
+++ b/arch/arm/mach-ixp23xx/roadrunner.c
@@ -137,9 +137,29 @@ static int __init roadrunner_pci_init(void)
 
 subsys_initcall(roadrunner_pci_init);
 
+static struct physmap_flash_data roadrunner_flash_data = {
+        .width          = 2,
+};
+
+static struct resource roadrunner_flash_resource = {
+        .start          = 0x90000000,
+        .end            = 0x94000000,
+        .flags          = IORESOURCE_MEM,
+};
+
+static struct platform_device roadrunner_flash = {
+        .name           = "physmap-flash",
+        .id             = 0,
+        .dev            = {
+                .platform_data  = &roadrunner_flash_data,
+        },
+        .num_resources  = 1,
+        .resource       = &roadrunner_flash_resource,
+};
+
 static void __init roadrunner_init(void)
 {
-        physmap_configure(0x90000000, 0x04000000, 2, NULL);
+        platform_device_register(&roadrunner_flash);
 
         /*
          * Mark flash as writeable
diff --git a/arch/arm/mach-ixp4xx/common.c b/arch/arm/mach-ixp4xx/common.c
index 00b761ff0f9c..bf25a76e9bdf 100644
--- a/arch/arm/mach-ixp4xx/common.c
+++ b/arch/arm/mach-ixp4xx/common.c
@@ -276,7 +276,7 @@ static irqreturn_t ixp4xx_timer_interrupt(int irq, void *dev_id, struct pt_regs
         /*
          * Catch up with the real idea of time
          */
-        while ((*IXP4XX_OSTS - last_jiffy_time) > LATCH) {
+        while ((signed long)(*IXP4XX_OSTS - last_jiffy_time) >= LATCH) {
                 timer_tick(regs);
                 last_jiffy_time += LATCH;
         }
diff --git a/arch/arm/mach-ixp4xx/nas100d-setup.c b/arch/arm/mach-ixp4xx/nas100d-setup.c
index a3b4c6ac5708..9a31444d9214 100644
--- a/arch/arm/mach-ixp4xx/nas100d-setup.c
+++ b/arch/arm/mach-ixp4xx/nas100d-setup.c
@@ -15,6 +15,7 @@
 #include <linux/kernel.h>
 #include <linux/serial.h>
 #include <linux/serial_8250.h>
+#include <linux/leds.h>
 
 #include <asm/mach-types.h>
 #include <asm/mach/arch.h>
@@ -37,6 +38,36 @@ static struct platform_device nas100d_flash = {
         .resource               = &nas100d_flash_resource,
 };
 
+#ifdef CONFIG_LEDS_IXP4XX
+static struct resource nas100d_led_resources[] = {
+        {
+                .name           = "wlan",   /* green led */
+                .start          = 0,
+                .end            = 0,
+                .flags          = IXP4XX_GPIO_LOW,
+        },
+        {
+                .name           = "ready",  /* blue power led (off is flashing!) */
+                .start          = 15,
+                .end            = 15,
+                .flags          = IXP4XX_GPIO_LOW,
+        },
+        {
+                .name           = "disk",   /* yellow led */
+                .start          = 3,
+                .end            = 3,
+                .flags          = IXP4XX_GPIO_LOW,
+        },
+};
+
+static struct platform_device nas100d_leds = {
+        .name                   = "IXP4XX-GPIO-LED",
+        .id                     = -1,
+        .num_resources          = ARRAY_SIZE(nas100d_led_resources),
+        .resource               = nas100d_led_resources,
+};
+#endif
+
 static struct ixp4xx_i2c_pins nas100d_i2c_gpio_pins = {
         .sda_pin                = NAS100D_SDA_PIN,
         .scl_pin                = NAS100D_SCL_PIN,
@@ -95,7 +126,9 @@ static struct platform_device nas100d_uart = {
 static struct platform_device *nas100d_devices[] __initdata = {
         &nas100d_i2c_controller,
         &nas100d_flash,
-        &nas100d_uart,
+#ifdef CONFIG_LEDS_IXP4XX
+        &nas100d_leds,
+#endif
 };
 
 static void nas100d_power_off(void)
@@ -122,6 +155,12 @@ static void __init nas100d_init(void)
 
         pm_power_off = nas100d_power_off;
 
+        /* This is only useful on a modified machine, but it is valuable
+         * to have it first in order to see debug messages, and so that
+         * it does *not* get removed if platform_add_devices fails!
+         */
+        (void)platform_device_register(&nas100d_uart);
+
         platform_add_devices(nas100d_devices, ARRAY_SIZE(nas100d_devices));
 }
 
diff --git a/arch/arm/mach-ixp4xx/nslu2-setup.c b/arch/arm/mach-ixp4xx/nslu2-setup.c
index 55411f21d838..749a337494d3 100644
--- a/arch/arm/mach-ixp4xx/nslu2-setup.c
+++ b/arch/arm/mach-ixp4xx/nslu2-setup.c
@@ -7,6 +7,7 @@
  *      Copyright (C) 2003-2004 MontaVista Software, Inc.
  *
  * Author: Mark Rakes <mrakes at mac.com>
+ * Author: Rod Whitby <rod@whitby.id.au>
  * Maintainers: http://www.nslu2-linux.org/
  *
  * Fixed missing init_time in MACHINE_START kas11 10/22/04
@@ -16,6 +17,7 @@
 #include <linux/kernel.h>
 #include <linux/serial.h>
 #include <linux/serial_8250.h>
+#include <linux/leds.h>
 
 #include <asm/mach-types.h>
 #include <asm/mach/arch.h>
@@ -43,6 +45,42 @@ static struct ixp4xx_i2c_pins nslu2_i2c_gpio_pins = {
         .scl_pin                = NSLU2_SCL_PIN,
 };
 
+#ifdef CONFIG_LEDS_IXP4XX
+static struct resource nslu2_led_resources[] = {
+        {
+                .name           = "ready",  /* green led */
+                .start          = NSLU2_LED_GRN,
+                .end            = NSLU2_LED_GRN,
+                .flags          = IXP4XX_GPIO_HIGH,
+        },
+        {
+                .name           = "status", /* red led */
+                .start          = NSLU2_LED_RED,
+                .end            = NSLU2_LED_RED,
+                .flags          = IXP4XX_GPIO_HIGH,
+        },
+        {
+                .name           = "disk-1",
+                .start          = NSLU2_LED_DISK1,
+                .end            = NSLU2_LED_DISK1,
+                .flags          = IXP4XX_GPIO_LOW,
+        },
+        {
+                .name           = "disk-2",
+                .start          = NSLU2_LED_DISK2,
+                .end            = NSLU2_LED_DISK2,
+                .flags          = IXP4XX_GPIO_LOW,
+        },
+};
+
+static struct platform_device nslu2_leds = {
+        .name                   = "IXP4XX-GPIO-LED",
+        .id                     = -1,
+        .num_resources          = ARRAY_SIZE(nslu2_led_resources),
+        .resource               = nslu2_led_resources,
+};
+#endif
+
 static struct platform_device nslu2_i2c_controller = {
         .name                   = "IXP4XX-I2C",
         .id                     = 0,
@@ -102,8 +140,10 @@ static struct platform_device nslu2_uart = {
 static struct platform_device *nslu2_devices[] __initdata = {
         &nslu2_i2c_controller,
         &nslu2_flash,
-        &nslu2_uart,
         &nslu2_beeper,
+#ifdef CONFIG_LEDS_IXP4XX
+        &nslu2_leds,
+#endif
 };
 
 static void nslu2_power_off(void)
@@ -127,6 +167,12 @@ static void __init nslu2_init(void)
 
         pm_power_off = nslu2_power_off;
 
+        /* This is only useful on a modified machine, but it is valuable
+         * to have it first in order to see debug messages, and so that
+         * it does *not* get removed if platform_add_devices fails!
+         */
+        (void)platform_device_register(&nslu2_uart);
+
         platform_add_devices(nslu2_devices, ARRAY_SIZE(nslu2_devices));
 }
 
diff --git a/arch/arm/mach-omap1/board-ams-delta.c b/arch/arm/mach-omap1/board-ams-delta.c
index 6178f046f128..73df32aac4c4 100644
--- a/arch/arm/mach-omap1/board-ams-delta.c
+++ b/arch/arm/mach-omap1/board-ams-delta.c
@@ -84,6 +84,15 @@ static struct omap_board_config_kernel ams_delta_config[] = {
         { OMAP_TAG_UART,        &ams_delta_uart_config },
 };
 
+static struct platform_device ams_delta_led_device = {
+        .name   = "ams-delta-led",
+        .id     = -1
+};
+
+static struct platform_device *ams_delta_devices[] __initdata = {
+        &ams_delta_led_device,
+};
+
 static void __init ams_delta_init(void)
 {
         iotable_init(ams_delta_io_desc, ARRAY_SIZE(ams_delta_io_desc));
@@ -94,6 +103,8 @@ static void __init ams_delta_init(void)
 
         /* Clear latch2 (NAND, LCD, modem enable) */
         ams_delta_latch2_write(~0, 0);
+
+        platform_add_devices(ams_delta_devices, ARRAY_SIZE(ams_delta_devices));
 }
 
 static void __init ams_delta_map_io(void)
diff --git a/arch/arm/mach-pnx4008/clock.c b/arch/arm/mach-pnx4008/clock.c
index 285b22f631e9..f582ed2ec43c 100644
--- a/arch/arm/mach-pnx4008/clock.c
+++ b/arch/arm/mach-pnx4008/clock.c
@@ -767,6 +767,54 @@ static struct clk *onchip_clks[] = {
         &uart6_ck,
 };
 
+static int local_clk_enable(struct clk *clk)
+{
+        int ret = 0;
+
+        if (!(clk->flags & FIXED_RATE) && !clk->rate && clk->set_rate
+            && clk->user_rate)
+                ret = clk->set_rate(clk, clk->user_rate);
+        return ret;
+}
+
+static void local_clk_disable(struct clk *clk)
+{
+        if (!(clk->flags & FIXED_RATE) && clk->rate && clk->set_rate)
+                clk->set_rate(clk, 0);
+}
+
+static void local_clk_unuse(struct clk *clk)
+{
+        if (clk->usecount > 0 && !(--clk->usecount)) {
+                local_clk_disable(clk);
+                if (clk->parent)
+                        local_clk_unuse(clk->parent);
+        }
+}
+
+static int local_clk_use(struct clk *clk)
+{
+        int ret = 0;
+        if (clk->usecount++ == 0) {
+                if (clk->parent)
+                        ret = local_clk_use(clk->parent);
+
+                if (ret != 0) {
+                        clk->usecount--;
+                        goto out;
+                }
+
+                ret = local_clk_enable(clk);
+
+                if (ret != 0 && clk->parent) {
+                        local_clk_unuse(clk->parent);
+                        clk->usecount--;
+                }
+        }
+out:
+        return ret;
+}
+
 static int local_set_rate(struct clk *clk, u32 rate)
 {
         int ret = -EINVAL;
@@ -847,28 +895,12 @@ unsigned long clk_get_rate(struct clk *clk)
 }
 EXPORT_SYMBOL(clk_get_rate);
 
-static int local_clk_enable(struct clk *clk)
-{
-        int ret = 0;
-
-        if (!(clk->flags & FIXED_RATE) && !clk->rate && clk->set_rate
-            && clk->user_rate)
-                ret = clk->set_rate(clk, clk->user_rate);
-        return ret;
-}
-
-static void local_clk_disable(struct clk *clk)
-{
-        if (!(clk->flags & FIXED_RATE) && clk->rate && clk->set_rate)
-                clk->set_rate(clk, 0);
-}
-
 int clk_enable(struct clk *clk)
 {
         int ret = 0;
 
         clock_lock();
-        ret = local_clk_enable(clk);
+        ret = local_clk_use(clk);
         clock_unlock();
         return ret;
 }
@@ -878,70 +910,11 @@ EXPORT_SYMBOL(clk_enable);
 void clk_disable(struct clk *clk)
 {
         clock_lock();
-        local_clk_disable(clk);
-        clock_unlock();
-}
-
-EXPORT_SYMBOL(clk_disable);
-
-static void local_clk_unuse(struct clk *clk)
-{
-        if (clk->usecount > 0 && !(--clk->usecount)) {
-                local_clk_disable(clk);
-                if (clk->parent)
-                        local_clk_unuse(clk->parent);
-        }
-}
-
-static int local_clk_use(struct clk *clk)
-{
-        int ret = 0;
-        if (clk->usecount++ == 0) {
-                if (clk->parent)
-                        ret = local_clk_use(clk->parent);
-
-                if (ret != 0) {
-                        clk->usecount--;
-                        goto out;
-                }
-
-                ret = local_clk_enable(clk);
-
-                if (ret != 0 && clk->parent) {
-                        local_clk_unuse(clk->parent);
-                        clk->usecount--;
-                }
-        }
-out:
-        return ret;
-}
-
-/* The main purpose of clk_use ans clk_unuse functions
- * is to control switching 13MHz oscillator and PLL1 (13'MHz),
- * so that they are disabled whenever none of PLL2-5 is using them.
- * Although in theory these functions should work with any clock,
- * please use them only on PLL2 - PLL5 to avoid confusion.
- */
-int clk_use(struct clk *clk)
-{
-        int ret = 0;
-
-        clock_lock();
-        ret = local_clk_use(clk);
-        clock_unlock();
-        return ret;
-}
-EXPORT_SYMBOL(clk_use);
-
-void clk_unuse(struct clk *clk)
-{
-
-        clock_lock();
         local_clk_unuse(clk);
         clock_unlock();
 }
 
-EXPORT_SYMBOL(clk_unuse);
+EXPORT_SYMBOL(clk_disable);
 
 long clk_round_rate(struct clk *clk, unsigned long rate)
 {
@@ -995,7 +968,7 @@ static int __init clk_init(void)
                         __FUNCTION__, (*clkp)->name, (*clkp)->rate);
         }
 
-        clk_use(&ck_pll4);
+        local_clk_use(&ck_pll4);
 
         /* if ck_13MHz is not used, disable it. */
         if (ck_13MHz.usecount == 0)
diff --git a/arch/arm/mach-pnx4008/serial.c b/arch/arm/mach-pnx4008/serial.c
index 10322384e45d..95a1b3f964a2 100644
--- a/arch/arm/mach-pnx4008/serial.c
+++ b/arch/arm/mach-pnx4008/serial.c
@@ -20,7 +20,7 @@
 
 #include <linux/serial_core.h>
 #include <linux/serial_reg.h>
-#include <asm/arch/pm.h>
+#include <asm/arch/gpio.h>
 
 #include <asm/arch/clock.h>
 
diff --git a/arch/arm/mach-s3c2410/Kconfig b/arch/arm/mach-s3c2410/Kconfig
index 0c334136db7c..7b786d725636 100644
--- a/arch/arm/mach-s3c2410/Kconfig
+++ b/arch/arm/mach-s3c2410/Kconfig
@@ -114,9 +114,15 @@ config MACH_NEXCODER_2440
 
 endmenu
 
+config S3C2410_CLOCK
+        bool
+        help
+          Clock code for the S3C2410, and similar processors
+
 config CPU_S3C2410
         bool
         depends on ARCH_S3C2410
+        select S3C2410_CLOCK
         help
           Support for S3C2410 and S3C2410A family from the S3C24XX line
           of Samsung Mobile CPUs.
@@ -130,6 +136,7 @@ config CPU_S3C244X
 config CPU_S3C2440
         bool
         depends on ARCH_S3C2410
+        select S3C2410_CLOCK
         select CPU_S3C244X
         help
           Support for S3C2440 Samsung Mobile CPU based systems.
@@ -137,6 +144,7 @@ config CPU_S3C2440
 config CPU_S3C2442
         bool
         depends on ARCH_S3C2420
+        select S3C2410_CLOCK
         select CPU_S3C244X
         help
           Support for S3C2442 Samsung Mobile CPU based systems.
diff --git a/arch/arm/mach-s3c2410/Makefile b/arch/arm/mach-s3c2410/Makefile
index 5e09355cd4f4..372dbcea1434 100644
--- a/arch/arm/mach-s3c2410/Makefile
+++ b/arch/arm/mach-s3c2410/Makefile
@@ -29,6 +29,10 @@ obj-$(CONFIG_PM_SIMTEC)	   += pm-simtec.o
 obj-$(CONFIG_CPU_S3C244X)  += s3c244x.o
 obj-$(CONFIG_CPU_S3C244X)  += s3c244x-irq.o
 
+# Clock control
+
+obj-$(CONFIG_S3C2410_CLOCK) += s3c2410-clock.o
+
 # S3C2440 support
 
 obj-$(CONFIG_CPU_S3C2440)  += s3c2440.o s3c2440-dsc.o
diff --git a/arch/arm/mach-s3c2410/clock.c b/arch/arm/mach-s3c2410/clock.c
index 99d174612b53..c5c93c333ac6 100644
--- a/arch/arm/mach-s3c2410/clock.c
+++ b/arch/arm/mach-s3c2410/clock.c
@@ -3,7 +3,7 @@
  * Copyright (c) 2004-2005 Simtec Electronics
  *      Ben Dooks <ben@simtec.co.uk>
  *
- * S3C2410 Clock control support
+ * S3C24XX Core clock control support
  *
  * Based on, and code from linux/arch/arm/mach-versatile/clock.c
  **
@@ -56,25 +56,6 @@ static LIST_HEAD(clocks);
 
 DEFINE_MUTEX(clocks_mutex);
 
-/* old functions */
-
-void inline s3c24xx_clk_enable(unsigned int clocks, unsigned int enable)
-{
-        unsigned long clkcon;
-
-        clkcon = __raw_readl(S3C2410_CLKCON);
-
-        if (enable)
-                clkcon |= clocks;
-        else
-                clkcon &= ~clocks;
-
-        /* ensure none of the special function bits set */
-        clkcon &= ~(S3C2410_CLKCON_IDLE|S3C2410_CLKCON_POWER | 3);
-
-        __raw_writel(clkcon, S3C2410_CLKCON);
-}
-
 /* enable and disable calls for use with the clk struct */
 
 static int clk_null_enable(struct clk *clk, int enable)
@@ -82,12 +63,6 @@ static int clk_null_enable(struct clk *clk, int enable)
         return 0;
 }
 
-int s3c24xx_clkcon_enable(struct clk *clk, int enable)
-{
-        s3c24xx_clk_enable(clk->ctrlbit, enable);
-        return 0;
-}
-
 /* Clock API calls */
 
 struct clk *clk_get(struct device *dev, const char *id)
@@ -173,8 +148,11 @@ unsigned long clk_get_rate(struct clk *clk)
         if (clk->rate != 0)
                 return clk->rate;
 
-        while (clk->parent != NULL && clk->rate == 0)
-                clk = clk->parent;
+        if (clk->get_rate != NULL)
+                return (clk->get_rate)(clk);
+
+        if (clk->parent != NULL)
+                return clk_get_rate(clk->parent);
 
         return clk->rate;
 }
@@ -233,28 +211,6 @@ EXPORT_SYMBOL(clk_set_rate);
 EXPORT_SYMBOL(clk_get_parent);
 EXPORT_SYMBOL(clk_set_parent);
 
-/* base clock enable */
-
-static int s3c24xx_upll_enable(struct clk *clk, int enable)
-{
-        unsigned long clkslow = __raw_readl(S3C2410_CLKSLOW);
-        unsigned long orig = clkslow;
-
-        if (enable)
-                clkslow &= ~S3C2410_CLKSLOW_UCLK_OFF;
-        else
-                clkslow |= S3C2410_CLKSLOW_UCLK_OFF;
-
-        __raw_writel(clkslow, S3C2410_CLKSLOW);
-
-        /* if we started the UPLL, then allow to settle */
-
-        if (enable && (orig & S3C2410_CLKSLOW_UCLK_OFF))
-                udelay(200);
-
-        return 0;
-}
-
 /* base clocks */
 
 static struct clk clk_xtal = {
@@ -265,15 +221,14 @@ static struct clk clk_xtal = {
         .ctrlbit        = 0,
 };
 
-static struct clk clk_upll = {
+struct clk clk_upll = {
         .name           = "upll",
         .id             = -1,
         .parent         = NULL,
-        .enable         = s3c24xx_upll_enable,
         .ctrlbit        = 0,
 };
 
-static struct clk clk_f = {
+struct clk clk_f = {
         .name           = "fclk",
         .id             = -1,
         .rate           = 0,
@@ -281,7 +236,7 @@ static struct clk clk_f = {
         .ctrlbit        = 0,
 };
 
-static struct clk clk_h = {
+struct clk clk_h = {
         .name           = "hclk",
         .id             = -1,
         .rate           = 0,
@@ -289,7 +244,7 @@ static struct clk clk_h = {
         .ctrlbit        = 0,
 };
 
-static struct clk clk_p = {
+struct clk clk_p = {
         .name           = "pclk",
         .id             = -1,
         .rate           = 0,
@@ -426,108 +381,6 @@ struct clk s3c24xx_uclk = {
         .id             = -1,
 };
 
-
-/* standard clock definitions */
-
-static struct clk init_clocks[] = {
-        {
-                .name           = "nand",
-                .id             = -1,
-                .parent         = &clk_h,
-                .enable         = s3c24xx_clkcon_enable,
-                .ctrlbit        = S3C2410_CLKCON_NAND,
-        }, {
-                .name           = "lcd",
-                .id             = -1,
-                .parent         = &clk_h,
-                .enable         = s3c24xx_clkcon_enable,
-                .ctrlbit        = S3C2410_CLKCON_LCDC,
-        }, {
-                .name           = "usb-host",
-                .id             = -1,
-                .parent         = &clk_h,
-                .enable         = s3c24xx_clkcon_enable,
-                .ctrlbit        = S3C2410_CLKCON_USBH,
-        }, {
-                .name           = "usb-device",
-                .id             = -1,
-                .parent         = &clk_h,
-                .enable         = s3c24xx_clkcon_enable,
-                .ctrlbit        = S3C2410_CLKCON_USBD,
-        }, {
-                .name           = "timers",
-                .id             = -1,
-                .parent         = &clk_p,
-                .enable         = s3c24xx_clkcon_enable,
-                .ctrlbit        = S3C2410_CLKCON_PWMT,
-        }, {
-                .name           = "sdi",
-                .id             = -1,
-                .parent         = &clk_p,
-                .enable         = s3c24xx_clkcon_enable,
-                .ctrlbit        = S3C2410_CLKCON_SDI,
-        }, {
-                .name           = "uart",
-                .id             = 0,
-                .parent         = &clk_p,
-                .enable         = s3c24xx_clkcon_enable,
-                .ctrlbit        = S3C2410_CLKCON_UART0,
-        }, {
-                .name           = "uart",
-                .id             = 1,
-                .parent         = &clk_p,
-                .enable         = s3c24xx_clkcon_enable,
-                .ctrlbit        = S3C2410_CLKCON_UART1,
-        }, {
-                .name           = "uart",
-                .id             = 2,
-                .parent         = &clk_p,
-                .enable         = s3c24xx_clkcon_enable,
-                .ctrlbit        = S3C2410_CLKCON_UART2,
-        }, {
-                .name           = "gpio",
-                .id             = -1,
-                .parent         = &clk_p,
-                .enable         = s3c24xx_clkcon_enable,
-                .ctrlbit        = S3C2410_CLKCON_GPIO,
-        }, {
-                .name           = "rtc",
-                .id             = -1,
-                .parent         = &clk_p,
-                .enable         = s3c24xx_clkcon_enable,
-                .ctrlbit        = S3C2410_CLKCON_RTC,
-        }, {
-                .name           = "adc",
-                .id             = -1,
-                .parent         = &clk_p,
-                .enable         = s3c24xx_clkcon_enable,
-                .ctrlbit        = S3C2410_CLKCON_ADC,
-        }, {
-                .name           = "i2c",
-                .id             = -1,
-                .parent         = &clk_p,
-                .enable         = s3c24xx_clkcon_enable,
-                .ctrlbit        = S3C2410_CLKCON_IIC,
-        }, {
-                .name           = "iis",
-                .id             = -1,
-                .parent         = &clk_p,
-                .enable         = s3c24xx_clkcon_enable,
-                .ctrlbit        = S3C2410_CLKCON_IIS,
-        }, {
-                .name           = "spi",
-                .id             = -1,
-                .parent         = &clk_p,
-                .enable         = s3c24xx_clkcon_enable,
-                .ctrlbit        = S3C2410_CLKCON_SPI,
-        }, {
-                .name           = "watchdog",
-                .id             = -1,
-                .parent         = &clk_p,
-                .ctrlbit        = 0,
-        }
-};
-
 /* initialise the clock system */
 
 int s3c24xx_register_clock(struct clk *clk)
@@ -537,14 +390,6 @@ int s3c24xx_register_clock(struct clk *clk)
         if (clk->enable == NULL)
                 clk->enable = clk_null_enable;
 
-        /* if this is a standard clock, set the usage state */
-
-        if (clk->ctrlbit && clk->enable == s3c24xx_clkcon_enable) {
-                unsigned long clkcon = __raw_readl(S3C2410_CLKCON);
-
-                clk->usage = (clkcon & clk->ctrlbit) ? 1 : 0;
-        }
-
         /* add to the list of available clocks */
 
         mutex_lock(&clocks_mutex);
@@ -561,44 +406,17 @@ int __init s3c24xx_setup_clocks(unsigned long xtal,
                                 unsigned long hclk,
                                 unsigned long pclk)
 {
-        unsigned long upllcon = __raw_readl(S3C2410_UPLLCON);
-        unsigned long clkslow = __raw_readl(S3C2410_CLKSLOW);
-        struct clk *clkp = init_clocks;
-        int ptr;
-        int ret;
-
-        printk(KERN_INFO "S3C2410 Clocks, (c) 2004 Simtec Electronics\n");
+        printk(KERN_INFO "S3C24XX Clocks, (c) 2004 Simtec Electronics\n");
 
         /* initialise the main system clocks */
 
         clk_xtal.rate = xtal;
-        clk_upll.rate = s3c2410_get_pll(upllcon, xtal);
+        clk_upll.rate = s3c2410_get_pll(__raw_readl(S3C2410_UPLLCON), xtal);
 
         clk_h.rate = hclk;
         clk_p.rate = pclk;
         clk_f.rate = fclk;
 
-        /* We must be careful disabling the clocks we are not intending to
-         * be using at boot time, as subsytems such as the LCD which do
-         * their own DMA requests to the bus can cause the system to lockup
-         * if they where in the middle of requesting bus access.
-         *
-         * Disabling the LCD clock if the LCD is active is very dangerous,
-         * and therefore the bootloader should be  careful to not enable
-         * the LCD clock if it is not needed.
-        */
-
-        mutex_lock(&clocks_mutex);
-
-        s3c24xx_clk_enable(S3C2410_CLKCON_NAND, 0);
-        s3c24xx_clk_enable(S3C2410_CLKCON_USBH, 0);
-        s3c24xx_clk_enable(S3C2410_CLKCON_USBD, 0);
-        s3c24xx_clk_enable(S3C2410_CLKCON_ADC, 0);
-        s3c24xx_clk_enable(S3C2410_CLKCON_IIC, 0);
-        s3c24xx_clk_enable(S3C2410_CLKCON_SPI, 0);
-
-        mutex_unlock(&clocks_mutex);
-
         /* assume uart clocks are correctly setup */
 
         /* register our clocks */
@@ -618,27 +436,5 @@ int __init s3c24xx_setup_clocks(unsigned long xtal,
         if (s3c24xx_register_clock(&clk_p) < 0)
                 printk(KERN_ERR "failed to register cpu pclk\n");
 
-
-        if (s3c24xx_register_clock(&clk_usb_bus) < 0)
-                printk(KERN_ERR "failed to register usb bus clock\n");
-
-        /* register clocks from clock array */
-
-        for (ptr = 0; ptr < ARRAY_SIZE(init_clocks); ptr++, clkp++) {
-                ret = s3c24xx_register_clock(clkp);
-                if (ret < 0) {
-                        printk(KERN_ERR "Failed to register clock %s (%d)\n",
-                               clkp->name, ret);
-                }
-        }
-
-        /* show the clock-slow value */
-
-        printk("CLOCK: Slow mode (%ld.%ld MHz), %s, MPLL %s, UPLL %s\n",
-               print_mhz(xtal / ( 2 * S3C2410_CLKSLOW_GET_SLOWVAL(clkslow))),
-               (clkslow & S3C2410_CLKSLOW_SLOW) ? "slow" : "fast",
-               (clkslow & S3C2410_CLKSLOW_MPLL_OFF) ? "off" : "on",
-               (clkslow & S3C2410_CLKSLOW_UCLK_OFF) ? "off" : "on");
-
         return 0;
 }
diff --git a/arch/arm/mach-s3c2410/clock.h b/arch/arm/mach-s3c2410/clock.h
index 01bb458bf8eb..9456c81eb5d3 100644
--- a/arch/arm/mach-s3c2410/clock.h
+++ b/arch/arm/mach-s3c2410/clock.h
@@ -22,6 +22,7 @@ struct clk {
 
         int                 (*enable)(struct clk *, int enable);
         int                 (*set_rate)(struct clk *c, unsigned long rate);
+        unsigned long       (*get_rate)(struct clk *c);
         unsigned long       (*round_rate)(struct clk *c, unsigned long rate);
         int                 (*set_parent)(struct clk *c, struct clk *parent);
 };
@@ -36,6 +37,13 @@ extern struct clk s3c24xx_uclk;
 
 extern struct clk clk_usb_bus;
 
+/* core clock support */
+
+extern struct clk clk_f;
+extern struct clk clk_h;
+extern struct clk clk_p;
+extern struct clk clk_upll;
+
 /* exports for arch/arm/mach-s3c2410
  *
  * Please DO NOT use these outside of arch/arm/mach-s3c2410
@@ -43,7 +51,8 @@ extern struct clk clk_usb_bus;
 
 extern struct mutex clocks_mutex;
 
-extern int s3c24xx_clkcon_enable(struct clk *clk, int enable);
+extern int s3c2410_clkcon_enable(struct clk *clk, int enable);
+
 extern int s3c24xx_register_clock(struct clk *clk);
 
 extern int s3c24xx_setup_clocks(unsigned long xtal,
diff --git a/arch/arm/mach-s3c2410/cpu.h b/arch/arm/mach-s3c2410/cpu.h
index 40862899b2f1..21c62dc29bb2 100644
--- a/arch/arm/mach-s3c2410/cpu.h
+++ b/arch/arm/mach-s3c2410/cpu.h
@@ -73,5 +73,6 @@ extern struct sys_timer s3c24xx_timer;
 
 /* system device classes */
 
+extern struct sysdev_class s3c2410_sysclass;
 extern struct sysdev_class s3c2440_sysclass;
 extern struct sysdev_class s3c2442_sysclass;
diff --git a/arch/arm/mach-s3c2410/s3c2410-clock.c b/arch/arm/mach-s3c2410/s3c2410-clock.c
new file mode 100644
index 000000000000..fd17c60e1132
--- /dev/null
+++ b/arch/arm/mach-s3c2410/s3c2410-clock.c
@@ -0,0 +1,263 @@
+/* linux/arch/arm/mach-s3c2410/clock.c
+ *
+ * Copyright (c) 2006 Simtec Electronics
+ *      Ben Dooks <ben@simtec.co.uk>
+ *
+ * S3C2410,S3C2440,S3C2442 Clock control support
+ *
+ * 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/module.h>
+#include <linux/kernel.h>
+#include <linux/list.h>
+#include <linux/errno.h>
+#include <linux/err.h>
+#include <linux/sysdev.h>
+#include <linux/clk.h>
+#include <linux/mutex.h>
+#include <linux/delay.h>
+
+#include <asm/hardware.h>
+#include <asm/io.h>
+
+#include <asm/arch/regs-clock.h>
+#include <asm/arch/regs-gpio.h>
+
+#include "clock.h"
+#include "cpu.h"
+
+int s3c2410_clkcon_enable(struct clk *clk, int enable)
+{
+        unsigned int clocks = clk->ctrlbit;
+        unsigned long clkcon;
+
+        clkcon = __raw_readl(S3C2410_CLKCON);
+
+        if (enable)
+                clkcon |= clocks;
+        else
+                clkcon &= ~clocks;
+
+        /* ensure none of the special function bits set */
+        clkcon &= ~(S3C2410_CLKCON_IDLE|S3C2410_CLKCON_POWER);
+
+        __raw_writel(clkcon, S3C2410_CLKCON);
+
+        return 0;
+}
+
+static int s3c2410_upll_enable(struct clk *clk, int enable)
+{
+        unsigned long clkslow = __raw_readl(S3C2410_CLKSLOW);
+        unsigned long orig = clkslow;
+
+        if (enable)
+                clkslow &= ~S3C2410_CLKSLOW_UCLK_OFF;
+        else
+                clkslow |= S3C2410_CLKSLOW_UCLK_OFF;
+
+        __raw_writel(clkslow, S3C2410_CLKSLOW);
+
+        /* if we started the UPLL, then allow to settle */
+
+        if (enable && (orig & S3C2410_CLKSLOW_UCLK_OFF))
+                udelay(200);
+
+        return 0;
+}
+
+/* standard clock definitions */
+
+static struct clk init_clocks_disable[] = {
+        {
+                .name           = "nand",
+                .id             = -1,
+                .parent         = &clk_h,
+                .enable         = s3c2410_clkcon_enable,
+                .ctrlbit        = S3C2410_CLKCON_NAND,
+        }, {
+                .name           = "sdi",
+                .id             = -1,
+                .parent         = &clk_p,
+                .enable         = s3c2410_clkcon_enable,
+                .ctrlbit        = S3C2410_CLKCON_SDI,
+        }, {
+                .name           = "adc",
+                .id             = -1,
+                .parent         = &clk_p,
+                .enable         = s3c2410_clkcon_enable,
+                .ctrlbit        = S3C2410_CLKCON_ADC,
+        }, {
+                .name           = "i2c",
+                .id             = -1,
+                .parent         = &clk_p,
+                .enable         = s3c2410_clkcon_enable,
+                .ctrlbit        = S3C2410_CLKCON_IIC,
+        }, {
+                .name           = "iis",
+                .id             = -1,
+                .parent         = &clk_p,
+                .enable         = s3c2410_clkcon_enable,
+                .ctrlbit        = S3C2410_CLKCON_IIS,
+        }, {
+                .name           = "spi",
+                .id             = -1,
+                .parent         = &clk_p,
+                .enable         = s3c2410_clkcon_enable,
+                .ctrlbit        = S3C2410_CLKCON_SPI,
+        }
+};
+
+static struct clk init_clocks[] = {
+        {
+                .name           = "lcd",
+                .id             = -1,
+                .parent         = &clk_h,
+                .enable         = s3c2410_clkcon_enable,
+                .ctrlbit        = S3C2410_CLKCON_LCDC,
+        }, {
+                .name           = "gpio",
+                .id             = -1,
+                .parent         = &clk_p,
+                .enable         = s3c2410_clkcon_enable,
+                .ctrlbit        = S3C2410_CLKCON_GPIO,
+        }, {
+                .name           = "usb-host",
+                .id             = -1,
+                .parent         = &clk_h,
+                .enable         = s3c2410_clkcon_enable,
+                .ctrlbit        = S3C2410_CLKCON_USBH,
+        }, {
+                .name           = "usb-device",
+                .id             = -1,
+                .parent         = &clk_h,
+                .enable         = s3c2410_clkcon_enable,
+                .ctrlbit        = S3C2410_CLKCON_USBD,
+        }, {
+                .name           = "timers",
+                .id             = -1,
+                .parent         = &clk_p,
+                .enable         = s3c2410_clkcon_enable,
+                .ctrlbit        = S3C2410_CLKCON_PWMT,
+        }, {
+                .name           = "uart",
+                .id             = 0,
+                .parent         = &clk_p,
+                .enable         = s3c2410_clkcon_enable,
+                .ctrlbit        = S3C2410_CLKCON_UART0,
+        }, {
+                .name           = "uart",
+                .id             = 1,
+                .parent         = &clk_p,
+                .enable         = s3c2410_clkcon_enable,
+                .ctrlbit        = S3C2410_CLKCON_UART1,
+        }, {
+                .name           = "uart",
+                .id             = 2,
+                .parent         = &clk_p,
+                .enable         = s3c2410_clkcon_enable,
+                .ctrlbit        = S3C2410_CLKCON_UART2,
+        }, {
+                .name           = "rtc",
+                .id             = -1,
+                .parent         = &clk_p,
+                .enable         = s3c2410_clkcon_enable,
+                .ctrlbit        = S3C2410_CLKCON_RTC,
+        }, {
+                .name           = "watchdog",
+                .id             = -1,
+                .parent         = &clk_p,
+                .ctrlbit        = 0,
+        }
+};
+
+/* s3c2410_baseclk_add()
+ *
+ * Add all the clocks used by the s3c2410 or compatible CPUs
+ * such as the S3C2440 and S3C2442.
+ *
+ * We cannot use a system device as we are needed before any
+ * of the init-calls that initialise the devices are actually
+ * done.
+*/
+
+int __init s3c2410_baseclk_add(void)
+{
+        unsigned long clkslow = __raw_readl(S3C2410_CLKSLOW);
+        unsigned long clkcon  = __raw_readl(S3C2410_CLKCON);
+        struct clk *clkp;
+        struct clk *xtal;
+        int ret;
+        int ptr;
+
+        clk_upll.enable = s3c2410_upll_enable;
+
+        if (s3c24xx_register_clock(&clk_usb_bus) < 0)
+                printk(KERN_ERR "failed to register usb bus clock\n");
+
+        /* register clocks from clock array */
+
+        clkp = init_clocks;
+        for (ptr = 0; ptr < ARRAY_SIZE(init_clocks); ptr++, clkp++) {
+                /* ensure that we note the clock state */
+
+                clkp->usage = clkcon & clkp->ctrlbit ? 1 : 0;
+
+                ret = s3c24xx_register_clock(clkp);
+                if (ret < 0) {
+                        printk(KERN_ERR "Failed to register clock %s (%d)\n",
+                               clkp->name, ret);
+                }
+        }
+
+        /* We must be careful disabling the clocks we are not intending to
+         * be using at boot time, as subsytems such as the LCD which do
+         * their own DMA requests to the bus can cause the system to lockup
+         * if they where in the middle of requesting bus access.
+         *
+         * Disabling the LCD clock if the LCD is active is very dangerous,
+         * and therefore the bootloader should be careful to not enable
+         * the LCD clock if it is not needed.
+        */
+
+        /* install (and disable) the clocks we do not need immediately */
+
+        clkp = init_clocks_disable;
+        for (ptr = 0; ptr < ARRAY_SIZE(init_clocks_disable); ptr++, clkp++) {
+
+                ret = s3c24xx_register_clock(clkp);
+                if (ret < 0) {
+                        printk(KERN_ERR "Failed to register clock %s (%d)\n",
+                               clkp->name, ret);
+                }
+
+                s3c2410_clkcon_enable(clkp, 0);
+        }
+
+        /* show the clock-slow value */
+
+        xtal = clk_get(NULL, "xtal");
+
+        printk("CLOCK: Slow mode (%ld.%ld MHz), %s, MPLL %s, UPLL %s\n",
+               print_mhz(clk_get_rate(xtal) /
+                         ( 2 * S3C2410_CLKSLOW_GET_SLOWVAL(clkslow))),
+               (clkslow & S3C2410_CLKSLOW_SLOW) ? "slow" : "fast",
+               (clkslow & S3C2410_CLKSLOW_MPLL_OFF) ? "off" : "on",
+               (clkslow & S3C2410_CLKSLOW_UCLK_OFF) ? "off" : "on");
+
+        return 0;
+}
diff --git a/arch/arm/mach-s3c2410/s3c2410.c b/arch/arm/mach-s3c2410/s3c2410.c
index 0852e87a79c4..a110cff9cf6b 100644
--- a/arch/arm/mach-s3c2410/s3c2410.c
+++ b/arch/arm/mach-s3c2410/s3c2410.c
@@ -27,6 +27,7 @@
 #include <linux/list.h>
 #include <linux/timer.h>
 #include <linux/init.h>
+#include <linux/sysdev.h>
 #include <linux/platform_device.h>
 
 #include <asm/mach/arch.h>
@@ -108,11 +109,33 @@ void __init s3c2410_init_clocks(int xtal)
          */
 
         s3c24xx_setup_clocks(xtal, fclk, hclk, pclk);
+        s3c2410_baseclk_add();
 }
 
+struct sysdev_class s3c2410_sysclass = {
+        set_kset_name("s3c2410-core"),
+};
+
+static struct sys_device s3c2410_sysdev = {
+        .cls            = &s3c2410_sysclass,
+};
+
+/* need to register class before we actually register the device, and
+ * we also need to ensure that it has been initialised before any of the
+ * drivers even try to use it (even if not on an s3c2440 based system)
+ * as a driver which may support both 2410 and 2440 may try and use it.
+*/
+
+static int __init s3c2410_core_init(void)
+{
+        return sysdev_class_register(&s3c2410_sysclass);
+}
+
+core_initcall(s3c2410_core_init);
+
 int __init s3c2410_init(void)
 {
         printk("S3C2410: Initialising architecture\n");
 
-        return 0;
+        return sysdev_register(&s3c2410_sysdev);
 }
diff --git a/arch/arm/mach-s3c2410/s3c2410.h b/arch/arm/mach-s3c2410/s3c2410.h
index 4d5312a48209..73f1a2474a61 100644
--- a/arch/arm/mach-s3c2410/s3c2410.h
+++ b/arch/arm/mach-s3c2410/s3c2410.h
@@ -29,6 +29,8 @@ extern void s3c2410_init_uarts(struct s3c2410_uartcfg *cfg, int no);
 
 extern void s3c2410_init_clocks(int xtal);
 
+extern  int s3c2410_baseclk_add(void);
+
 #else
 #define s3c2410_init_clocks NULL
 #define s3c2410_init_uarts NULL
diff --git a/arch/arm/mach-s3c2410/s3c2440-clock.c b/arch/arm/mach-s3c2410/s3c2440-clock.c
index d7a30ed6c327..15796864d010 100644
--- a/arch/arm/mach-s3c2410/s3c2440-clock.c
+++ b/arch/arm/mach-s3c2410/s3c2440-clock.c
@@ -91,7 +91,7 @@ static int s3c2440_camif_upll_setrate(struct clk *clk, unsigned long rate)
 static struct clk s3c2440_clk_cam = {
         .name           = "camif",
         .id             = -1,
-        .enable         = s3c24xx_clkcon_enable,
+        .enable         = s3c2410_clkcon_enable,
         .ctrlbit        = S3C2440_CLKCON_CAMERA,
 };
 
@@ -105,7 +105,7 @@ static struct clk s3c2440_clk_cam_upll = {
 static struct clk s3c2440_clk_ac97 = {
         .name           = "ac97",
         .id             = -1,
-        .enable         = s3c24xx_clkcon_enable,
+        .enable         = s3c2410_clkcon_enable,
         .ctrlbit        = S3C2440_CLKCON_CAMERA,
 };
 
diff --git a/arch/arm/mach-s3c2410/s3c2442-clock.c b/arch/arm/mach-s3c2410/s3c2442-clock.c
index 5b7b301eb522..d9f54b5cab7f 100644
--- a/arch/arm/mach-s3c2410/s3c2442-clock.c
+++ b/arch/arm/mach-s3c2410/s3c2442-clock.c
@@ -102,7 +102,7 @@ static int s3c2442_camif_upll_setrate(struct clk *clk, unsigned long rate)
 static struct clk s3c2442_clk_cam = {
         .name           = "camif",
         .id             = -1,
-        .enable         = s3c24xx_clkcon_enable,
+        .enable         = s3c2410_clkcon_enable,
         .ctrlbit        = S3C2440_CLKCON_CAMERA,
 };
 
diff --git a/arch/arm/mach-s3c2410/s3c244x.c b/arch/arm/mach-s3c2410/s3c244x.c
index 96852a7000db..838bc525e836 100644
--- a/arch/arm/mach-s3c2410/s3c244x.c
+++ b/arch/arm/mach-s3c2410/s3c244x.c
@@ -34,6 +34,7 @@
 #include <asm/arch/regs-gpioj.h>
 #include <asm/arch/regs-dsc.h>
 
+#include "s3c2410.h"
 #include "s3c2440.h"
 #include "s3c244x.h"
 #include "clock.h"
@@ -118,6 +119,7 @@ void __init s3c244x_init_clocks(int xtal)
          */
 
         s3c24xx_setup_clocks(xtal, fclk, hclk, pclk);
+        s3c2410_baseclk_add();
 }
 
 #ifdef CONFIG_PM
diff --git a/arch/arm/nwfpe/fpmodule.c b/arch/arm/nwfpe/fpmodule.c
index 2dfe1ac42ee8..7d977d23f026 100644
--- a/arch/arm/nwfpe/fpmodule.c
+++ b/arch/arm/nwfpe/fpmodule.c
@@ -33,7 +33,8 @@
 #include <linux/signal.h>
 #include <linux/sched.h>
 #include <linux/init.h>
-/* XXX */
+
+#include <asm/thread_notify.h>
 
 #include "softfloat.h"
 #include "fpopcode.h"
@@ -56,16 +57,28 @@ void fp_send_sig(unsigned long sig, struct task_struct *p, int priv);
 extern char fpe_type[];
 #endif
 
+static int nwfpe_notify(struct notifier_block *self, unsigned long cmd, void *v)
+{
+        struct thread_info *thread = v;
+
+        if (cmd == THREAD_NOTIFY_FLUSH)
+                nwfpe_init_fpa(&thread->fpstate);
+
+        return NOTIFY_DONE;
+}
+
+static struct notifier_block nwfpe_notifier_block = {
+        .notifier_call = nwfpe_notify,
+};
+
 /* kernel function prototypes required */
 void fp_setup(void);
 
 /* external declarations for saved kernel symbols */
 extern void (*kern_fp_enter)(void);
-extern void (*fp_init)(union fp_state *);
 
 /* Original value of fp_enter from kernel before patched by fpe_init. */
 static void (*orig_fp_enter)(void);
-static void (*orig_fp_init)(union fp_state *);
 
 /* forward declarations */
 extern void nwfpe_enter(void);
@@ -88,20 +101,20 @@ static int __init fpe_init(void)
         printk(KERN_WARNING "NetWinder Floating Point Emulator V0.97 ("
                NWFPE_BITS " precision)\n");
 
+        thread_register_notifier(&nwfpe_notifier_block);
+
         /* Save pointer to the old FP handler and then patch ourselves in */
         orig_fp_enter = kern_fp_enter;
-        orig_fp_init = fp_init;
         kern_fp_enter = nwfpe_enter;
-        fp_init = nwfpe_init_fpa;
 
         return 0;
 }
 
 static void __exit fpe_exit(void)
 {
+        thread_unregister_notifier(&nwfpe_notifier_block);
         /* Restore the values we saved earlier. */
         kern_fp_enter = orig_fp_enter;
-        fp_init = orig_fp_init;
 }
 
 /*
diff --git a/arch/arm/plat-omap/timer32k.c b/arch/arm/plat-omap/timer32k.c
index b2a943bf11ef..3461a6c9665c 100644
--- a/arch/arm/plat-omap/timer32k.c
+++ b/arch/arm/plat-omap/timer32k.c
@@ -210,7 +210,8 @@ static irqreturn_t omap_32k_timer_interrupt(int irq, void *dev_id,
 
         now = omap_32k_sync_timer_read();
 
-        while (now - omap_32k_last_tick >= OMAP_32K_TICKS_PER_HZ) {
+        while ((signed long)(now - omap_32k_last_tick)
+                                                >= OMAP_32K_TICKS_PER_HZ) {
                 omap_32k_last_tick += OMAP_32K_TICKS_PER_HZ;
                 timer_tick(regs);
         }
diff --git a/arch/arm/vfp/Makefile b/arch/arm/vfp/Makefile
index afabac31dd1d..7e136e77971a 100644
--- a/arch/arm/vfp/Makefile
+++ b/arch/arm/vfp/Makefile
@@ -7,6 +7,9 @@
 # EXTRA_CFLAGS := -DDEBUG
 # EXTRA_AFLAGS := -DDEBUG
 
+AFLAGS          :=$(AFLAGS:-msoft-float=-Wa,-mfpu=softvfp+vfp)
+LDFLAGS         +=--no-warn-mismatch
+
 obj-y                   += vfp.o
 
-vfp-$(CONFIG_VFP)       += entry.o vfpmodule.o vfphw.o vfpsingle.o vfpdouble.o
+vfp-$(CONFIG_VFP)       += vfpmodule.o entry.o vfphw.o vfpsingle.o vfpdouble.o
diff --git a/arch/arm/vfp/vfphw.S b/arch/arm/vfp/vfphw.S
index a3f65b47aea9..eb683cd77163 100644
--- a/arch/arm/vfp/vfphw.S
+++ b/arch/arm/vfp/vfphw.S
@@ -192,7 +192,7 @@ vfp_get_double:
         add     pc, pc, r0, lsl #3
         mov     r0, r0
         .irp    dr,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15
-        mrrc    p11, 1, r0, r1, c\dr    @ fmrrd r0, r1, d\dr
+        fmrrd   r0, r1, d\dr
         mov     pc, lr
         .endr
 
@@ -206,6 +206,6 @@ vfp_put_double:
         add     pc, pc, r0, lsl #3
         mov     r0, r0
         .irp    dr,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15
-        mcrr    p11, 1, r1, r2, c\dr    @ fmdrr r1, r2, d\dr
+        fmdrr   d\dr, r1, r2
         mov     pc, lr
         .endr
diff --git a/arch/arm/vfp/vfpmodule.c b/arch/arm/vfp/vfpmodule.c
index 03486be04193..2476f4c2e760 100644
--- a/arch/arm/vfp/vfpmodule.c
+++ b/arch/arm/vfp/vfpmodule.c
@@ -15,6 +15,8 @@
 #include <linux/signal.h>
 #include <linux/sched.h>
 #include <linux/init.h>
+
+#include <asm/thread_notify.h>
 #include <asm/vfp.h>
 
 #include "vfpinstr.h"
@@ -36,38 +38,55 @@ union vfp_state *last_VFP_context;
  */
 unsigned int VFP_arch;
 
-/*
- * Per-thread VFP initialisation.
- */
-void vfp_flush_thread(union vfp_state *vfp)
+static int vfp_notifier(struct notifier_block *self, unsigned long cmd, void *v)
 {
-        memset(vfp, 0, sizeof(union vfp_state));
+        struct thread_info *thread = v;
+        union vfp_state *vfp = &thread->vfpstate;
 
-        vfp->hard.fpexc = FPEXC_ENABLE;
-        vfp->hard.fpscr = FPSCR_ROUND_NEAREST;
+        switch (cmd) {
+        case THREAD_NOTIFY_FLUSH:
+                /*
+                 * Per-thread VFP initialisation.
+                 */
+                memset(vfp, 0, sizeof(union vfp_state));
 
-        /*
-         * Disable VFP to ensure we initialise it first.
-         */
-        fmxr(FPEXC, fmrx(FPEXC) & ~FPEXC_ENABLE);
+                vfp->hard.fpexc = FPEXC_ENABLE;
+                vfp->hard.fpscr = FPSCR_ROUND_NEAREST;
 
-        /*
-         * Ensure we don't try to overwrite our newly initialised
-         * state information on the first fault.
-         */
-        if (last_VFP_context == vfp)
-                last_VFP_context = NULL;
-}
+                /*
+                 * Disable VFP to ensure we initialise it first.
+                 */
+                fmxr(FPEXC, fmrx(FPEXC) & ~FPEXC_ENABLE);
 
-/*
- * Per-thread VFP cleanup.
- */
-void vfp_release_thread(union vfp_state *vfp)
-{
-        if (last_VFP_context == vfp)
-                last_VFP_context = NULL;
+                /*
+                 * FALLTHROUGH: Ensure we don't try to overwrite our newly
+                 * initialised state information on the first fault.
+                 */
+
+        case THREAD_NOTIFY_RELEASE:
+                /*
+                 * Per-thread VFP cleanup.
+                 */
+                if (last_VFP_context == vfp)
+                        last_VFP_context = NULL;
+                break;
+
+        case THREAD_NOTIFY_SWITCH:
+                /*
+                 * Always disable VFP so we can lazily save/restore the
+                 * old state.
+                 */
+                fmxr(FPEXC, fmrx(FPEXC) & ~FPEXC_ENABLE);
+                break;
+        }
+
+        return NOTIFY_DONE;
 }
 
+static struct notifier_block vfp_notifier_block = {
+        .notifier_call  = vfp_notifier,
+};
+
 /*
  * Raise a SIGFPE for the current process.
  * sicode describes the signal being raised.
@@ -281,6 +300,8 @@ static int __init vfp_init(void)
                         (vfpsid & FPSID_VARIANT_MASK) >> FPSID_VARIANT_BIT,
                         (vfpsid & FPSID_REV_MASK) >> FPSID_REV_BIT);
                 vfp_vector = vfp_support_entry;
+
+                thread_register_notifier(&vfp_notifier_block);
         }
         return 0;
 }
diff --git a/arch/frv/kernel/entry.S b/arch/frv/kernel/entry.S
index a9b59527a741..81d94e41a189 100644
--- a/arch/frv/kernel/entry.S
+++ b/arch/frv/kernel/entry.S
@@ -1474,7 +1474,7 @@ sys_call_table:
         .long sys_mknodat
         .long sys_fchownat
         .long sys_futimesat
-        .long sys_newfstatat            /* 300 */
+        .long sys_fstatat64             /* 300 */
         .long sys_unlinkat
         .long sys_renameat
         .long sys_linkat
diff --git a/arch/frv/kernel/frv_ksyms.c b/arch/frv/kernel/frv_ksyms.c
index 0f273a7aca5a..dee637fffda5 100644
--- a/arch/frv/kernel/frv_ksyms.c
+++ b/arch/frv/kernel/frv_ksyms.c
@@ -26,16 +26,6 @@ extern long __memset_user(void *dst, const void *src, size_t count);
 EXPORT_SYMBOL(__ioremap);
 EXPORT_SYMBOL(iounmap);
 
-EXPORT_SYMBOL(strnlen);
-EXPORT_SYMBOL(strrchr);
-EXPORT_SYMBOL(strstr);
-EXPORT_SYMBOL(strchr);
-EXPORT_SYMBOL(strcat);
-EXPORT_SYMBOL(strlen);
-EXPORT_SYMBOL(strcmp);
-EXPORT_SYMBOL(strncmp);
-EXPORT_SYMBOL(strncpy);
-
 EXPORT_SYMBOL(ip_fast_csum);
 
 #if 0
@@ -44,8 +34,6 @@ EXPORT_SYMBOL(local_bh_count);
 #endif
 EXPORT_SYMBOL(kernel_thread);
 
-EXPORT_SYMBOL(enable_irq);
-EXPORT_SYMBOL(disable_irq);
 EXPORT_SYMBOL(__res_bus_clock_speed_HZ);
 EXPORT_SYMBOL(__page_offset);
 EXPORT_SYMBOL(__memcpy_user);
@@ -62,18 +50,12 @@ EXPORT_SYMBOL(memory_end);
 
 EXPORT_SYMBOL(__debug_bug_trap);
 
-/* Networking helper routines. */
-EXPORT_SYMBOL(csum_partial_copy);
-
 /* The following are special because they're not called
    explicitly (the C compiler generates them).  Fortunately,
    their interface isn't gonna change any time soon now, so
    it's OK to leave it out of version control.  */
 EXPORT_SYMBOL(memcpy);
 EXPORT_SYMBOL(memset);
-EXPORT_SYMBOL(memcmp);
-EXPORT_SYMBOL(memscan);
-EXPORT_SYMBOL(memmove);
 
 EXPORT_SYMBOL(__outsl_ns);
 EXPORT_SYMBOL(__insl_ns);
diff --git a/arch/frv/kernel/irq-routing.c b/arch/frv/kernel/irq-routing.c
index d4776d1f4e82..b90b70a761d1 100644
--- a/arch/frv/kernel/irq-routing.c
+++ b/arch/frv/kernel/irq-routing.c
@@ -112,7 +112,7 @@ struct irq_source frv_cpuuart[2] = {
 #define __CPUUART(X, A)                                         \
         [X] = {                                                 \
                 .muxname        = "uart",                       \
-                .muxdata        = (volatile void __iomem *) A,  \
+                .muxdata        = (volatile void __iomem *)(unsigned long)A,\
                 .irqmask        = 1 << IRQ_CPU_UART##X,         \
                 .doirq          = frv_cpuuart_doirq,            \
         }
@@ -136,7 +136,7 @@ struct irq_source frv_cpudma[8] = {
 #define __CPUDMA(X, A)                                          \
         [X] = {                                                 \
                 .muxname        = "dma",                        \
-                .muxdata        = (volatile void __iomem *) A,  \
+                .muxdata        = (volatile void __iomem *)(unsigned long)A,\
                 .irqmask        = 1 << IRQ_CPU_DMA##X,          \
                 .doirq          = frv_cpudma_doirq,             \
         }
@@ -164,7 +164,7 @@ struct irq_source frv_cputimer[3] = {
 #define __CPUTIMER(X)                                           \
         [X] = {                                                 \
                 .muxname        = "timer",                      \
-                .muxdata        = 0,                            \
+                .muxdata        = NULL,                         \
                 .irqmask        = 1 << IRQ_CPU_TIMER##X,        \
                 .doirq          = frv_cputimer_doirq,           \
         }
@@ -187,7 +187,7 @@ struct irq_source frv_cpuexternal[8] = {
 #define __CPUEXTERNAL(X)                                        \
         [X] = {                                                 \
                 .muxname        = "ext",                        \
-                .muxdata        = 0,                            \
+                .muxdata        = NULL,                         \
                 .irqmask        = 1 << IRQ_CPU_EXTERNAL##X,     \
                 .doirq          = frv_cpuexternal_doirq,        \
         }
diff --git a/arch/frv/kernel/irq.c b/arch/frv/kernel/irq.c
index 11fa326a8f62..8b112b361914 100644
--- a/arch/frv/kernel/irq.c
+++ b/arch/frv/kernel/irq.c
@@ -625,7 +625,7 @@ static struct proc_dir_entry * irq_dir [NR_IRQS];
 
 #define HEX_DIGITS 8
 
-static unsigned int parse_hex_value (const char *buffer,
+static unsigned int parse_hex_value (const char __user *buffer,
                                      unsigned long count, unsigned long *ret)
 {
         unsigned char hexnum [HEX_DIGITS];
@@ -672,7 +672,7 @@ static int prof_cpu_mask_read_proc (char *page, char **start, off_t off,
         return sprintf (page, "%08lx\n", *mask);
 }
 
-static int prof_cpu_mask_write_proc (struct file *file, const char *buffer,
+static int prof_cpu_mask_write_proc (struct file *file, const char __user *buffer,
                                         unsigned long count, void *data)
 {
         unsigned long *mask = (unsigned long *) data, full_count = count, err;
@@ -711,7 +711,7 @@ void init_irq_proc (void)
         int i;
 
         /* create /proc/irq */
-        root_irq_dir = proc_mkdir("irq", 0);
+        root_irq_dir = proc_mkdir("irq", NULL);
 
         /* create /proc/irq/prof_cpu_mask */
         entry = create_proc_entry("prof_cpu_mask", 0600, root_irq_dir);
diff --git a/arch/frv/kernel/pm.c b/arch/frv/kernel/pm.c
index f0b8fff3e733..43ce28a13a5d 100644
--- a/arch/frv/kernel/pm.c
+++ b/arch/frv/kernel/pm.c
@@ -137,7 +137,7 @@ unsigned long sleep_phys_sp(void *sp)
 #define CTL_PM_P0 4
 #define CTL_PM_CM 5
 
-static int user_atoi(char *ubuf, size_t len)
+static int user_atoi(char __user *ubuf, size_t len)
 {
         char buf[16];
         unsigned long ret;
@@ -159,7 +159,7 @@ static int user_atoi(char *ubuf, size_t len)
  * Send us to sleep.
  */
 static int sysctl_pm_do_suspend(ctl_table *ctl, int write, struct file *filp,
-                                void *buffer, size_t *lenp, loff_t *fpos)
+                                void __user *buffer, size_t *lenp, loff_t *fpos)
 {
         int retval, mode;
 
@@ -215,7 +215,7 @@ static int try_set_cmode(int new_cmode)
 
 
 static int cmode_procctl(ctl_table *ctl, int write, struct file *filp,
-                         void *buffer, size_t *lenp, loff_t *fpos)
+                         void __user *buffer, size_t *lenp, loff_t *fpos)
 {
         int new_cmode;
 
@@ -227,9 +227,9 @@ static int cmode_procctl(ctl_table *ctl, int write, struct file *filp,
         return try_set_cmode(new_cmode)?:*lenp;
 }
 
-static int cmode_sysctl(ctl_table *table, int *name, int nlen,
-                        void *oldval, size_t *oldlenp,
-                        void *newval, size_t newlen, void **context)
+static int cmode_sysctl(ctl_table *table, int __user *name, int nlen,
+                        void __user *oldval, size_t __user *oldlenp,
+                        void __user *newval, size_t newlen, void **context)
 {
         if (oldval && oldlenp) {
                 size_t oldlen;
@@ -240,7 +240,7 @@ static int cmode_sysctl(ctl_table *table, int *name, int nlen,
                 if (oldlen != sizeof(int))
                         return -EINVAL;
 
-                if (put_user(clock_cmode_current, (unsigned int *)oldval) ||
+                if (put_user(clock_cmode_current, (unsigned __user *)oldval) ||
                     put_user(sizeof(int), oldlenp))
                         return -EFAULT;
         }
@@ -250,7 +250,7 @@ static int cmode_sysctl(ctl_table *table, int *name, int nlen,
                 if (newlen != sizeof(int))
                         return -EINVAL;
 
-                if (get_user(new_cmode, (int *)newval))
+                if (get_user(new_cmode, (int __user *)newval))
                         return -EFAULT;
 
                 return try_set_cmode(new_cmode)?:1;
@@ -318,7 +318,7 @@ static int try_set_cm(int new_cm)
 }
 
 static int p0_procctl(ctl_table *ctl, int write, struct file *filp,
-                      void *buffer, size_t *lenp, loff_t *fpos)
+                      void __user *buffer, size_t *lenp, loff_t *fpos)
 {
         int new_p0;
 
@@ -330,9 +330,9 @@ static int p0_procctl(ctl_table *ctl, int write, struct file *filp,
         return try_set_p0(new_p0)?:*lenp;
 }
 
-static int p0_sysctl(ctl_table *table, int *name, int nlen,
-                     void *oldval, size_t *oldlenp,
-                     void *newval, size_t newlen, void **context)
+static int p0_sysctl(ctl_table *table, int __user *name, int nlen,
+                     void __user *oldval, size_t __user *oldlenp,
+                     void __user *newval, size_t newlen, void **context)
 {
         if (oldval && oldlenp) {
                 size_t oldlen;
@@ -343,7 +343,7 @@ static int p0_sysctl(ctl_table *table, int *name, int nlen,
                 if (oldlen != sizeof(int))
                         return -EINVAL;
 
-                if (put_user(clock_p0_current, (unsigned int *)oldval) ||
+                if (put_user(clock_p0_current, (unsigned __user *)oldval) ||
                     put_user(sizeof(int), oldlenp))
                         return -EFAULT;
         }
@@ -353,7 +353,7 @@ static int p0_sysctl(ctl_table *table, int *name, int nlen,
                 if (newlen != sizeof(int))
                         return -EINVAL;
 
-                if (get_user(new_p0, (int *)newval))
+                if (get_user(new_p0, (int __user *)newval))
                         return -EFAULT;
 
                 return try_set_p0(new_p0)?:1;
@@ -362,7 +362,7 @@ static int p0_sysctl(ctl_table *table, int *name, int nlen,
 }
 
 static int cm_procctl(ctl_table *ctl, int write, struct file *filp,
-                      void *buffer, size_t *lenp, loff_t *fpos)
+                      void __user *buffer, size_t *lenp, loff_t *fpos)
 {
         int new_cm;
 
@@ -374,9 +374,9 @@ static int cm_procctl(ctl_table *ctl, int write, struct file *filp,
         return try_set_cm(new_cm)?:*lenp;
 }
 
-static int cm_sysctl(ctl_table *table, int *name, int nlen,
-                     void *oldval, size_t *oldlenp,
-                     void *newval, size_t newlen, void **context)
+static int cm_sysctl(ctl_table *table, int __user *name, int nlen,
+                     void __user *oldval, size_t __user *oldlenp,
+                     void __user *newval, size_t newlen, void **context)
 {
         if (oldval && oldlenp) {
                 size_t oldlen;
@@ -387,7 +387,7 @@ static int cm_sysctl(ctl_table *table, int *name, int nlen,
                 if (oldlen != sizeof(int))
                         return -EINVAL;
 
-                if (put_user(clock_cm_current, (unsigned int *)oldval) ||
+                if (put_user(clock_cm_current, (unsigned __user *)oldval) ||
                     put_user(sizeof(int), oldlenp))
                         return -EFAULT;
         }
@@ -397,7 +397,7 @@ static int cm_sysctl(ctl_table *table, int *name, int nlen,
                 if (newlen != sizeof(int))
                         return -EINVAL;
 
-                if (get_user(new_cm, (int *)newval))
+                if (get_user(new_cm, (int __user *)newval))
                         return -EFAULT;
 
                 return try_set_cm(new_cm)?:1;
diff --git a/arch/frv/kernel/process.c b/arch/frv/kernel/process.c
index 0fff8a61ef2a..489e6c489cbe 100644
--- a/arch/frv/kernel/process.c
+++ b/arch/frv/kernel/process.c
@@ -246,7 +246,7 @@ int copy_thread(int nr, unsigned long clone_flags,
 /*
  * sys_execve() executes a new program.
  */
-asmlinkage int sys_execve(char *name, char **argv, char **envp)
+asmlinkage int sys_execve(char __user *name, char __user * __user *argv, char __user * __user *envp)
 {
         int error;
         char * filename;
diff --git a/arch/frv/kernel/setup.c b/arch/frv/kernel/setup.c
index 5908deae9607..1f7d65f29e78 100644
--- a/arch/frv/kernel/setup.c
+++ b/arch/frv/kernel/setup.c
@@ -814,7 +814,7 @@ void __init setup_arch(char **cmdline_p)
          * - by now the stack is part of the init task */
         printk("Memory %08lx-%08lx\n", memory_start, memory_end);
 
-        if (memory_start == memory_end) BUG();
+        BUG_ON(memory_start == memory_end);
 
         init_mm.start_code = (unsigned long) &_stext;
         init_mm.end_code = (unsigned long) &_etext;
diff --git a/arch/frv/kernel/signal.c b/arch/frv/kernel/signal.c
index 679c1d5cc958..b8a5882b8625 100644
--- a/arch/frv/kernel/signal.c
+++ b/arch/frv/kernel/signal.c
@@ -98,7 +98,7 @@ int sys_sigaltstack(const stack_t __user *uss, stack_t __user *uoss)
 
 struct sigframe
 {
-        void (*pretcode)(void);
+        __sigrestore_t pretcode;
         int sig;
         struct sigcontext sc;
         unsigned long extramask[_NSIG_WORDS-1];
@@ -107,10 +107,10 @@ struct sigframe
 
 struct rt_sigframe
 {
-        void (*pretcode)(void);
+        __sigrestore_t pretcode;
         int sig;
-        struct siginfo *pinfo;
-        void *puc;
+        struct siginfo __user *pinfo;
+        void __user *puc;
         struct siginfo info;
         struct ucontext uc;
         uint32_t retcode[2];
@@ -233,7 +233,7 @@ static inline void __user *get_sigframe(struct k_sigaction *ka,
 
         /* This is the X/Open sanctioned signal stack switching.  */
         if (ka->sa.sa_flags & SA_ONSTACK) {
-                if (! on_sig_stack(sp))
+                if (! sas_ss_flags(sp))
                         sp = current->sas_ss_sp + current->sas_ss_size;
         }
 
@@ -284,7 +284,7 @@ static int setup_frame(int sig, struct k_sigaction *ka, sigset_t *set)
                  *      setlos  #__NR_sigreturn,gr7
                  *      tira    gr0,0
                  */
-                if (__put_user((void (*)(void))frame->retcode, &frame->pretcode) ||
+                if (__put_user((__sigrestore_t)frame->retcode, &frame->pretcode) ||
                     __put_user(0x8efc0000|__NR_sigreturn, &frame->retcode[0]) ||
                     __put_user(0xc0700000, &frame->retcode[1]))
                         goto give_sigsegv;
@@ -300,7 +300,7 @@ static int setup_frame(int sig, struct k_sigaction *ka, sigset_t *set)
 
         if (get_personality & FDPIC_FUNCPTRS) {
                 struct fdpic_func_descriptor __user *funcptr =
-                        (struct fdpic_func_descriptor *) ka->sa.sa_handler;
+                        (struct fdpic_func_descriptor __user *) ka->sa.sa_handler;
                 __get_user(__frame->pc, &funcptr->text);
                 __get_user(__frame->gr15, &funcptr->GOT);
         } else {
@@ -359,8 +359,8 @@ static int setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
 
         /* Create the ucontext.  */
         if (__put_user(0, &frame->uc.uc_flags) ||
-            __put_user(0, &frame->uc.uc_link) ||
-            __put_user((void*)current->sas_ss_sp, &frame->uc.uc_stack.ss_sp) ||
+            __put_user(NULL, &frame->uc.uc_link) ||
+            __put_user((void __user *)current->sas_ss_sp, &frame->uc.uc_stack.ss_sp) ||
             __put_user(sas_ss_flags(__frame->sp), &frame->uc.uc_stack.ss_flags) ||
             __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size))
                 goto give_sigsegv;
@@ -382,7 +382,7 @@ static int setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
                  *      setlos  #__NR_sigreturn,gr7
                  *      tira    gr0,0
                  */
-                if (__put_user((void (*)(void))frame->retcode, &frame->pretcode) ||
+                if (__put_user((__sigrestore_t)frame->retcode, &frame->pretcode) ||
                     __put_user(0x8efc0000|__NR_rt_sigreturn, &frame->retcode[0]) ||
                     __put_user(0xc0700000, &frame->retcode[1]))
                         goto give_sigsegv;
@@ -398,7 +398,7 @@ static int setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
         __frame->gr9 = (unsigned long) &frame->info;
 
         if (get_personality & FDPIC_FUNCPTRS) {
-                struct fdpic_func_descriptor *funcptr =
+                struct fdpic_func_descriptor __user *funcptr =
                         (struct fdpic_func_descriptor __user *) ka->sa.sa_handler;
                 __get_user(__frame->pc, &funcptr->text);
                 __get_user(__frame->gr15, &funcptr->GOT);
diff --git a/arch/frv/kernel/sys_frv.c b/arch/frv/kernel/sys_frv.c
index 931aa6d895e3..c4d4348c9e8e 100644
--- a/arch/frv/kernel/sys_frv.c
+++ b/arch/frv/kernel/sys_frv.c
@@ -32,7 +32,7 @@
  * sys_pipe() is the normal C calling standard for creating
  * a pipe. It's not the way unix traditionally does this, though.
  */
-asmlinkage long sys_pipe(unsigned long * fildes)
+asmlinkage long sys_pipe(unsigned long __user * fildes)
 {
         int fd[2];
         int error;
diff --git a/arch/frv/kernel/sysctl.c b/arch/frv/kernel/sysctl.c
index 408b0f382b42..b908863d6593 100644
--- a/arch/frv/kernel/sysctl.c
+++ b/arch/frv/kernel/sysctl.c
@@ -49,7 +49,7 @@ static void frv_change_dcache_mode(unsigned long newmode)
  * handle requests to dynamically switch the write caching mode delivered by /proc
  */
 static int procctl_frv_cachemode(ctl_table *table, int write, struct file *filp,
-                                 void *buffer, size_t *lenp, loff_t *ppos)
+                                 void __user *buffer, size_t *lenp, loff_t *ppos)
 {
         unsigned long hsr0;
         char buff[8];
@@ -123,7 +123,7 @@ static int procctl_frv_cachemode(ctl_table *table, int write, struct file *filp,
  */
 #ifdef CONFIG_MMU
 static int procctl_frv_pin_cxnr(ctl_table *table, int write, struct file *filp,
-                                void *buffer, size_t *lenp, loff_t *ppos)
+                                void __user *buffer, size_t *lenp, loff_t *ppos)
 {
         pid_t pid;
         char buff[16], *p;
diff --git a/arch/frv/kernel/uaccess.c b/arch/frv/kernel/uaccess.c
index 9b751c0f0e84..9fb771a20df3 100644
--- a/arch/frv/kernel/uaccess.c
+++ b/arch/frv/kernel/uaccess.c
@@ -17,7 +17,7 @@
 /*
  * copy a null terminated string from userspace
  */
-long strncpy_from_user(char *dst, const char *src, long count)
+long strncpy_from_user(char *dst, const char __user *src, long count)
 {
         unsigned long max;
         char *p, ch;
@@ -70,9 +70,9 @@ EXPORT_SYMBOL(strncpy_from_user);
  *
  * Return 0 on exception, a value greater than N if too long
  */
-long strnlen_user(const char *src, long count)
+long strnlen_user(const char __user *src, long count)
 {
-        const char *p;
+        const char __user *p;
         long err = 0;
         char ch;
 
diff --git a/arch/frv/mb93090-mb00/pci-irq.c b/arch/frv/mb93090-mb00/pci-irq.c
index c4a1144c98b0..45ae39d84b69 100644
--- a/arch/frv/mb93090-mb00/pci-irq.c
+++ b/arch/frv/mb93090-mb00/pci-irq.c
@@ -32,11 +32,11 @@
  */
 
 static const uint8_t __initdata pci_bus0_irq_routing[32][4] = {
-        [0 ] {  IRQ_FPGA_MB86943_PCI_INTA },
-        [16] {  IRQ_FPGA_RTL8029_INTA },
-        [17] {  IRQ_FPGA_PCI_INTC, IRQ_FPGA_PCI_INTD, IRQ_FPGA_PCI_INTA, IRQ_FPGA_PCI_INTB },
-        [18] {  IRQ_FPGA_PCI_INTB, IRQ_FPGA_PCI_INTC, IRQ_FPGA_PCI_INTD, IRQ_FPGA_PCI_INTA },
-        [19] {  IRQ_FPGA_PCI_INTA, IRQ_FPGA_PCI_INTB, IRQ_FPGA_PCI_INTC, IRQ_FPGA_PCI_INTD },
+        [0 ] = { IRQ_FPGA_MB86943_PCI_INTA },
+        [16] = { IRQ_FPGA_RTL8029_INTA },
+        [17] = { IRQ_FPGA_PCI_INTC, IRQ_FPGA_PCI_INTD, IRQ_FPGA_PCI_INTA, IRQ_FPGA_PCI_INTB },
+        [18] = { IRQ_FPGA_PCI_INTB, IRQ_FPGA_PCI_INTC, IRQ_FPGA_PCI_INTD, IRQ_FPGA_PCI_INTA },
+        [19] = { IRQ_FPGA_PCI_INTA, IRQ_FPGA_PCI_INTB, IRQ_FPGA_PCI_INTC, IRQ_FPGA_PCI_INTD },
 };
 
 void __init pcibios_irq_init(void)
diff --git a/arch/frv/mm/kmap.c b/arch/frv/mm/kmap.c
index c54f18e65ea6..40b62c5c2951 100644
--- a/arch/frv/mm/kmap.c
+++ b/arch/frv/mm/kmap.c
@@ -31,15 +31,15 @@
  * Map some physical address range into the kernel address space.
  */
 
-void *__ioremap(unsigned long physaddr, unsigned long size, int cacheflag)
+void __iomem *__ioremap(unsigned long physaddr, unsigned long size, int cacheflag)
 {
-        return (void *)physaddr;
+        return (void __iomem *)physaddr;
 }
 
 /*
  * Unmap a ioremap()ed region again
  */
-void iounmap(void *addr)
+void iounmap(void volatile __iomem *addr)
 {
 }
 
diff --git a/arch/h8300/kernel/signal.c b/arch/h8300/kernel/signal.c
index f13d5e82d4b9..7787f70a05bb 100644
--- a/arch/h8300/kernel/signal.c
+++ b/arch/h8300/kernel/signal.c
@@ -307,7 +307,7 @@ get_sigframe(struct k_sigaction *ka, struct pt_regs *regs, size_t frame_size)
 
         /* This is the X/Open sanctioned signal stack switching.  */
         if (ka->sa.sa_flags & SA_ONSTACK) {
-                if (!on_sig_stack(usp))
+                if (!sas_ss_flags(usp))
                         usp = current->sas_ss_sp + current->sas_ss_size;
         }
         return (void *)((usp - frame_size) & -8UL);
diff --git a/arch/i386/Kconfig b/arch/i386/Kconfig
index 8dfa3054f10f..1596101cfaf8 100644
--- a/arch/i386/Kconfig
+++ b/arch/i386/Kconfig
@@ -173,6 +173,12 @@ config ACPI_SRAT
         bool
         default y
         depends on NUMA && (X86_SUMMIT || X86_GENERICARCH)
+        select ACPI_NUMA
+
+config HAVE_ARCH_PARSE_SRAT
+       bool
+       default y
+       depends on ACPI_SRAT
 
 config X86_SUMMIT_NUMA
         bool
@@ -224,7 +230,6 @@ config NR_CPUS
 config SCHED_SMT
         bool "SMT (Hyperthreading) scheduler support"
         depends on SMP
-        default off
         help
           SMT scheduler support improves the CPU scheduler's decision making
           when dealing with Intel Pentium 4 chips with HyperThreading at a
diff --git a/arch/i386/kernel/acpi/boot.c b/arch/i386/kernel/acpi/boot.c
index 40e5aba3ad3d..97ca17189af5 100644
--- a/arch/i386/kernel/acpi/boot.c
+++ b/arch/i386/kernel/acpi/boot.c
@@ -202,6 +202,8 @@ int __init acpi_parse_mcfg(unsigned long phys_addr, unsigned long size)
                 if (mcfg->config[i].base_reserved) {
                         printk(KERN_ERR PREFIX
                                "MMCONFIG not in low 4GB of memory\n");
+                        kfree(pci_mmcfg_config);
+                        pci_mmcfg_config_num = 0;
                         return -ENODEV;
                 }
         }
@@ -215,7 +217,7 @@ static int __init acpi_parse_madt(unsigned long phys_addr, unsigned long size)
 {
         struct acpi_table_madt *madt = NULL;
 
-        if (!phys_addr || !size)
+        if (!phys_addr || !size || !cpu_has_apic)
                 return -EINVAL;
 
         madt = (struct acpi_table_madt *)__acpi_map_table(phys_addr, size);
@@ -621,9 +623,9 @@ extern u32 pmtmr_ioport;
 
 static int __init acpi_parse_fadt(unsigned long phys, unsigned long size)
 {
-        struct fadt_descriptor_rev2 *fadt = NULL;
+        struct fadt_descriptor *fadt = NULL;
 
-        fadt = (struct fadt_descriptor_rev2 *)__acpi_map_table(phys, size);
+        fadt = (struct fadt_descriptor *)__acpi_map_table(phys, size);
         if (!fadt) {
                 printk(KERN_WARNING PREFIX "Unable to map FADT\n");
                 return 0;
@@ -754,7 +756,7 @@ static int __init acpi_parse_madt_ioapic_entries(void)
                 return -ENODEV;
         }
 
-        if (!cpu_has_apic)
+        if (!cpu_has_apic) 
                 return -ENODEV;
 
         /*
diff --git a/arch/i386/kernel/acpi/processor.c b/arch/i386/kernel/acpi/processor.c
index 9f4cc02717ec..b54fded49834 100644
--- a/arch/i386/kernel/acpi/processor.c
+++ b/arch/i386/kernel/acpi/processor.c
@@ -47,7 +47,7 @@ static void init_intel_pdc(struct acpi_processor *pr, struct cpuinfo_x86 *c)
         buf[2] = ACPI_PDC_C_CAPABILITY_SMP;
 
         if (cpu_has(c, X86_FEATURE_EST))
-                buf[2] |= ACPI_PDC_EST_CAPABILITY_SMP;
+                buf[2] |= ACPI_PDC_EST_CAPABILITY_SWSMP;
 
         obj->type = ACPI_TYPE_BUFFER;
         obj->buffer.length = 12;
diff --git a/arch/i386/kernel/acpi/sleep.c b/arch/i386/kernel/acpi/sleep.c
index 1cb2b186a3af..4ee83577bf61 100644
--- a/arch/i386/kernel/acpi/sleep.c
+++ b/arch/i386/kernel/acpi/sleep.c
@@ -8,30 +8,17 @@
 #include <linux/acpi.h>
 #include <linux/bootmem.h>
 #include <linux/dmi.h>
+#include <linux/cpumask.h>
+
 #include <asm/smp.h>
-#include <asm/tlbflush.h>
 
 /* address in low memory of the wakeup routine. */
 unsigned long acpi_wakeup_address = 0;
 unsigned long acpi_video_flags;
 extern char wakeup_start, wakeup_end;
 
-extern void zap_low_mappings(void);
-
 extern unsigned long FASTCALL(acpi_copy_wakeup_routine(unsigned long));
 
-static void init_low_mapping(pgd_t * pgd, int pgd_limit)
-{
-        int pgd_ofs = 0;
-
-        while ((pgd_ofs < pgd_limit)
-               && (pgd_ofs + USER_PTRS_PER_PGD < PTRS_PER_PGD)) {
-                set_pgd(pgd, *(pgd + USER_PTRS_PER_PGD));
-                pgd_ofs++, pgd++;
-        }
-        flush_tlb_all();
-}
-
 /**
  * acpi_save_state_mem - save kernel state
  *
@@ -42,7 +29,6 @@ int acpi_save_state_mem(void)
 {
         if (!acpi_wakeup_address)
                 return 1;
-        init_low_mapping(swapper_pg_dir, USER_PTRS_PER_PGD);
         memcpy((void *)acpi_wakeup_address, &wakeup_start,
                &wakeup_end - &wakeup_start);
         acpi_copy_wakeup_routine(acpi_wakeup_address);
@@ -55,7 +41,6 @@ int acpi_save_state_mem(void)
  */
 void acpi_restore_state_mem(void)
 {
-        zap_low_mappings();
 }
 
 /**
diff --git a/arch/i386/kernel/acpi/wakeup.S b/arch/i386/kernel/acpi/wakeup.S
index 7c74fe0dc93c..9f408eee4e6f 100644
--- a/arch/i386/kernel/acpi/wakeup.S
+++ b/arch/i386/kernel/acpi/wakeup.S
@@ -56,7 +56,7 @@ wakeup_code:
 1:
 
         # set up page table
-        movl    $swapper_pg_dir-__PAGE_OFFSET, %eax
+        movl    $swsusp_pg_dir-__PAGE_OFFSET, %eax
         movl    %eax, %cr3
 
         testl   $1, real_efer_save_restore - wakeup_code
@@ -265,11 +265,6 @@ ENTRY(acpi_copy_wakeup_routine)
         movl    $0x12345678, saved_magic
         ret
 
-.data
-ALIGN
-ENTRY(saved_magic)      .long   0
-ENTRY(saved_eip)        .long   0
-
 save_registers:
         leal    4(%esp), %eax
         movl    %eax, saved_context_esp
@@ -304,7 +299,11 @@ ret_point:
         call    restore_processor_state
         ret
 
+.data
 ALIGN
+ENTRY(saved_magic)      .long   0
+ENTRY(saved_eip)        .long   0
+
 # saved registers
 saved_gdt:      .long   0,0
 saved_idt:      .long   0,0
diff --git a/arch/i386/kernel/apic.c b/arch/i386/kernel/apic.c
index 3d4b2f3d116a..5ab59c12335b 100644
--- a/arch/i386/kernel/apic.c
+++ b/arch/i386/kernel/apic.c
@@ -62,7 +62,7 @@ int apic_verbosity;
 
 static void apic_pm_activate(void);
 
-int modern_apic(void)
+static int modern_apic(void)
 {
         unsigned int lvr, version;
         /* AMD systems use old APIC versions, so check the CPU */
@@ -113,7 +113,7 @@ void __init apic_intr_init(void)
 }
 
 /* Using APIC to generate smp_local_timer_interrupt? */
-int using_apic_timer = 0;
+int using_apic_timer __read_mostly = 0;
 
 static int enabled_via_apicbase;
 
diff --git a/arch/i386/kernel/apm.c b/arch/i386/kernel/apm.c
index df0e1745f189..9e819eb68229 100644
--- a/arch/i386/kernel/apm.c
+++ b/arch/i386/kernel/apm.c
@@ -374,14 +374,14 @@ static struct {
         unsigned short  segment;
 }                               apm_bios_entry;
 static int                      clock_slowed;
-static int                      idle_threshold = DEFAULT_IDLE_THRESHOLD;
-static int                      idle_period = DEFAULT_IDLE_PERIOD;
+static int                      idle_threshold __read_mostly = DEFAULT_IDLE_THRESHOLD;
+static int                      idle_period __read_mostly = DEFAULT_IDLE_PERIOD;
 static int                      set_pm_idle;
 static int                      suspends_pending;
 static int                      standbys_pending;
 static int                      ignore_sys_suspend;
 static int                      ignore_normal_resume;
-static int                      bounce_interval = DEFAULT_BOUNCE_INTERVAL;
+static int                      bounce_interval __read_mostly = DEFAULT_BOUNCE_INTERVAL;
 
 #ifdef CONFIG_APM_RTC_IS_GMT
 #       define  clock_cmos_diff 0
@@ -390,8 +390,8 @@ static int			bounce_interval = DEFAULT_BOUNCE_INTERVAL;
 static long                     clock_cmos_diff;
 static int                      got_clock_diff;
 #endif
-static int                      debug;
-static int                      smp;
+static int                      debug __read_mostly;
+static int                      smp __read_mostly;
 static int                      apm_disabled = -1;
 #ifdef CONFIG_SMP
 static int                      power_off;
@@ -403,8 +403,8 @@ static int			realmode_power_off = 1;
 #else
 static int                      realmode_power_off;
 #endif
-static int                      exit_kapmd;
-static int                      kapmd_running;
+static int                      exit_kapmd __read_mostly;
+static int                      kapmd_running __read_mostly;
 #ifdef CONFIG_APM_ALLOW_INTS
 static int                      allow_ints = 1;
 #else
@@ -416,15 +416,15 @@ static DECLARE_WAIT_QUEUE_HEAD(apm_waitqueue);
 static DECLARE_WAIT_QUEUE_HEAD(apm_suspend_waitqueue);
 static struct apm_user *        user_list;
 static DEFINE_SPINLOCK(user_list_lock);
-static struct desc_struct       bad_bios_desc = { 0, 0x00409200 };
+static const struct desc_struct bad_bios_desc = { 0, 0x00409200 };
 
-static char                     driver_version[] = "1.16ac";    /* no spaces */
+static const char               driver_version[] = "1.16ac";    /* no spaces */
 
 /*
  *      APM event names taken from the APM 1.2 specification. These are
  *      the message codes that the BIOS uses to tell us about events
  */
-static char *   apm_event_name[] = {
+static const char *     const apm_event_name[] = {
         "system standby",
         "system suspend",
         "normal resume",
@@ -616,7 +616,7 @@ static u8 apm_bios_call(u32 func, u32 ebx_in, u32 ecx_in,
  *      @ecx_in: ECX register value for BIOS call
  *      @eax: EAX register on return from the BIOS call
  *
- *      Make a BIOS call that does only returns one value, or just status.
+ *      Make a BIOS call that returns one value only, or just status.
  *      If there is an error, then the error code is returned in AH
  *      (bits 8-15 of eax) and this function returns non-zero. This is
  *      used for simpler BIOS operations. This call may hold interrupts
@@ -822,7 +822,7 @@ static void apm_do_busy(void)
 #define IDLE_CALC_LIMIT   (HZ * 100)
 #define IDLE_LEAKY_MAX    16
 
-static void (*original_pm_idle)(void);
+static void (*original_pm_idle)(void) __read_mostly;
 
 /**
  * apm_cpu_idle         -       cpu idling for APM capable Linux
@@ -1063,7 +1063,8 @@ static int apm_engage_power_management(u_short device, int enable)
  
 static int apm_console_blank(int blank)
 {
-        int error, i;
+        int error = APM_NOT_ENGAGED; /* silence gcc */
+        int i;
         u_short state;
         static const u_short dev[3] = { 0x100, 0x1FF, 0x101 };
 
@@ -1104,7 +1105,8 @@ static int queue_empty(struct apm_user *as)
 
 static apm_event_t get_queued_event(struct apm_user *as)
 {
-        as->event_tail = (as->event_tail + 1) % APM_MAX_EVENTS;
+        if (++as->event_tail >= APM_MAX_EVENTS)
+                as->event_tail = 0;
         return as->events[as->event_tail];
 }
 
@@ -1118,13 +1120,16 @@ static void queue_event(apm_event_t event, struct apm_user *sender)
         for (as = user_list; as != NULL; as = as->next) {
                 if ((as == sender) || (!as->reader))
                         continue;
-                as->event_head = (as->event_head + 1) % APM_MAX_EVENTS;
+                if (++as->event_head >= APM_MAX_EVENTS)
+                        as->event_head = 0;
+
                 if (as->event_head == as->event_tail) {
                         static int notified;
 
                         if (notified++ == 0)
                             printk(KERN_ERR "apm: an event queue overflowed\n");
-                        as->event_tail = (as->event_tail + 1) % APM_MAX_EVENTS;
+                        if (++as->event_tail >= APM_MAX_EVENTS)
+                                as->event_tail = 0;
                 }
                 as->events[as->event_head] = event;
                 if ((!as->suser) || (!as->writer))
@@ -1282,7 +1287,7 @@ static void standby(void)
 static apm_event_t get_event(void)
 {
         int             error;
-        apm_event_t     event;
+        apm_event_t     event = APM_NO_EVENTS; /* silence gcc */
         apm_eventinfo_t info;
 
         static int notified;
diff --git a/arch/i386/kernel/cpu/common.c b/arch/i386/kernel/cpu/common.c
index a06a49075f10..44f2c5f2dda1 100644
--- a/arch/i386/kernel/cpu/common.c
+++ b/arch/i386/kernel/cpu/common.c
@@ -11,6 +11,8 @@
 #include <asm/msr.h>
 #include <asm/io.h>
 #include <asm/mmu_context.h>
+#include <asm/mtrr.h>
+#include <asm/mce.h>
 #ifdef CONFIG_X86_LOCAL_APIC
 #include <asm/mpspec.h>
 #include <asm/apic.h>
diff --git a/arch/i386/kernel/cpu/cpufreq/acpi-cpufreq.c b/arch/i386/kernel/cpu/cpufreq/acpi-cpufreq.c
index 1a7bdcef1926..05668e3598c0 100644
--- a/arch/i386/kernel/cpu/cpufreq/acpi-cpufreq.c
+++ b/arch/i386/kernel/cpu/cpufreq/acpi-cpufreq.c
@@ -48,12 +48,13 @@ MODULE_LICENSE("GPL");
 
 
 struct cpufreq_acpi_io {
-        struct acpi_processor_performance       acpi_data;
+        struct acpi_processor_performance       *acpi_data;
         struct cpufreq_frequency_table          *freq_table;
         unsigned int                            resume;
 };
 
 static struct cpufreq_acpi_io   *acpi_io_data[NR_CPUS];
+static struct acpi_processor_performance        *acpi_perf_data[NR_CPUS];
 
 static struct cpufreq_driver acpi_cpufreq_driver;
 
@@ -104,64 +105,43 @@ acpi_processor_set_performance (
 {
         u16                     port = 0;
         u8                      bit_width = 0;
-        int                     ret;
-        u32                     value = 0;
         int                     i = 0;
-        struct cpufreq_freqs    cpufreq_freqs;
-        cpumask_t               saved_mask;
+        int                     ret = 0;
+        u32                     value = 0;
         int                     retval;
+        struct acpi_processor_performance       *perf;
 
         dprintk("acpi_processor_set_performance\n");
 
-        /*
-         * TBD: Use something other than set_cpus_allowed.
-         * As set_cpus_allowed is a bit racy, 
-         * with any other set_cpus_allowed for this process.
-         */
-        saved_mask = current->cpus_allowed;
-        set_cpus_allowed(current, cpumask_of_cpu(cpu));
-        if (smp_processor_id() != cpu) {
-                return (-EAGAIN);
-        }
-        
-        if (state == data->acpi_data.state) {
+        retval = 0;
+        perf = data->acpi_data; 
+        if (state == perf->state) {
                 if (unlikely(data->resume)) {
                         dprintk("Called after resume, resetting to P%d\n", state);
                         data->resume = 0;
                 } else {
                         dprintk("Already at target state (P%d)\n", state);
-                        retval = 0;
-                        goto migrate_end;
+                        return (retval);
                 }
         }
 
-        dprintk("Transitioning from P%d to P%d\n",
-                data->acpi_data.state, state);
-
-        /* cpufreq frequency struct */
-        cpufreq_freqs.cpu = cpu;
-        cpufreq_freqs.old = data->freq_table[data->acpi_data.state].frequency;
-        cpufreq_freqs.new = data->freq_table[state].frequency;
-
-        /* notify cpufreq */
-        cpufreq_notify_transition(&cpufreq_freqs, CPUFREQ_PRECHANGE);
+        dprintk("Transitioning from P%d to P%d\n", perf->state, state);
 
         /*
          * First we write the target state's 'control' value to the
          * control_register.
          */
 
-        port = data->acpi_data.control_register.address;
-        bit_width = data->acpi_data.control_register.bit_width;
-        value = (u32) data->acpi_data.states[state].control;
+        port = perf->control_register.address;
+        bit_width = perf->control_register.bit_width;
+        value = (u32) perf->states[state].control;
 
         dprintk("Writing 0x%08x to port 0x%04x\n", value, port);
 
         ret = acpi_processor_write_port(port, bit_width, value);
         if (ret) {
                 dprintk("Invalid port width 0x%04x\n", bit_width);
-                retval = ret;
-                goto migrate_end;
+                return (ret);
         }
 
         /*
@@ -177,48 +157,35 @@ acpi_processor_set_performance (
                  * before giving up.
                  */
 
-                port = data->acpi_data.status_register.address;
-                bit_width = data->acpi_data.status_register.bit_width;
+                port = perf->status_register.address;
+                bit_width = perf->status_register.bit_width;
 
                 dprintk("Looking for 0x%08x from port 0x%04x\n",
-                        (u32) data->acpi_data.states[state].status, port);
+                        (u32) perf->states[state].status, port);
 
-                for (i=0; i<100; i++) {
+                for (i = 0; i < 100; i++) {
                         ret = acpi_processor_read_port(port, bit_width, &value);
                         if (ret) {      
                                 dprintk("Invalid port width 0x%04x\n", bit_width);
-                                retval = ret;
-                                goto migrate_end;
+                                return (ret);
                         }
-                        if (value == (u32) data->acpi_data.states[state].status)
+                        if (value == (u32) perf->states[state].status)
                                 break;
                         udelay(10);
                 }
         } else {
-                value = (u32) data->acpi_data.states[state].status;
+                value = (u32) perf->states[state].status;
         }
 
-        /* notify cpufreq */
-        cpufreq_notify_transition(&cpufreq_freqs, CPUFREQ_POSTCHANGE);
-
-        if (unlikely(value != (u32) data->acpi_data.states[state].status)) {
-                unsigned int tmp = cpufreq_freqs.new;
-                cpufreq_freqs.new = cpufreq_freqs.old;
-                cpufreq_freqs.old = tmp;
-                cpufreq_notify_transition(&cpufreq_freqs, CPUFREQ_PRECHANGE);
-                cpufreq_notify_transition(&cpufreq_freqs, CPUFREQ_POSTCHANGE);
+        if (unlikely(value != (u32) perf->states[state].status)) {
                 printk(KERN_WARNING "acpi-cpufreq: Transition failed\n");
                 retval = -ENODEV;
-                goto migrate_end;
+                return (retval);
         }
 
         dprintk("Transition successful after %d microseconds\n", i * 10);
 
-        data->acpi_data.state = state;
-
-        retval = 0;
-migrate_end:
-        set_cpus_allowed(current, saved_mask);
+        perf->state = state;
         return (retval);
 }
 
@@ -230,8 +197,17 @@ acpi_cpufreq_target (
         unsigned int relation)
 {
         struct cpufreq_acpi_io *data = acpi_io_data[policy->cpu];
+        struct acpi_processor_performance *perf;
+        struct cpufreq_freqs freqs;
+        cpumask_t online_policy_cpus;
+        cpumask_t saved_mask;
+        cpumask_t set_mask;
+        cpumask_t covered_cpus;
+        unsigned int cur_state = 0;
         unsigned int next_state = 0;
         unsigned int result = 0;
+        unsigned int j;
+        unsigned int tmp;
 
         dprintk("acpi_cpufreq_setpolicy\n");
 
@@ -240,11 +216,95 @@ acpi_cpufreq_target (
                         target_freq,
                         relation,
                         &next_state);
-        if (result)
+        if (unlikely(result))
                 return (result);
 
-        result = acpi_processor_set_performance (data, policy->cpu, next_state);
+        perf = data->acpi_data;
+        cur_state = perf->state;
+        freqs.old = data->freq_table[cur_state].frequency;
+        freqs.new = data->freq_table[next_state].frequency;
+
+#ifdef CONFIG_HOTPLUG_CPU
+        /* cpufreq holds the hotplug lock, so we are safe from here on */
+        cpus_and(online_policy_cpus, cpu_online_map, policy->cpus);
+#else
+        online_policy_cpus = policy->cpus;
+#endif
+
+        for_each_cpu_mask(j, online_policy_cpus) {
+                freqs.cpu = j;
+                cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
+        }
+
+        /*
+         * We need to call driver->target() on all or any CPU in
+         * policy->cpus, depending on policy->shared_type.
+         */
+        saved_mask = current->cpus_allowed;
+        cpus_clear(covered_cpus);
+        for_each_cpu_mask(j, online_policy_cpus) {
+                /*
+                 * Support for SMP systems.
+                 * Make sure we are running on CPU that wants to change freq
+                 */
+                cpus_clear(set_mask);
+                if (policy->shared_type == CPUFREQ_SHARED_TYPE_ANY)
+                        cpus_or(set_mask, set_mask, online_policy_cpus);
+                else
+                        cpu_set(j, set_mask);
+
+                set_cpus_allowed(current, set_mask);
+                if (unlikely(!cpu_isset(smp_processor_id(), set_mask))) {
+                        dprintk("couldn't limit to CPUs in this domain\n");
+                        result = -EAGAIN;
+                        break;
+                }
+
+                result = acpi_processor_set_performance (data, j, next_state);
+                if (result) {
+                        result = -EAGAIN;
+                        break;
+                }
+
+                if (policy->shared_type == CPUFREQ_SHARED_TYPE_ANY)
+                        break;
+ 
+                cpu_set(j, covered_cpus);
+        }
+
+        for_each_cpu_mask(j, online_policy_cpus) {
+                freqs.cpu = j;
+                cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
+        }
 
+        if (unlikely(result)) {
+                /*
+                 * We have failed halfway through the frequency change.
+                 * We have sent callbacks to online_policy_cpus and
+                 * acpi_processor_set_performance() has been called on 
+                 * coverd_cpus. Best effort undo..
+                 */
+
+                if (!cpus_empty(covered_cpus)) {
+                        for_each_cpu_mask(j, covered_cpus) {
+                                policy->cpu = j;
+                                acpi_processor_set_performance (data, 
+                                                j, 
+                                                cur_state);
+                        }
+                }
+
+                tmp = freqs.new;
+                freqs.new = freqs.old;
+                freqs.old = tmp;
+                for_each_cpu_mask(j, online_policy_cpus) {
+                        freqs.cpu = j;
+                        cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
+                        cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
+                }
+        }
+
+        set_cpus_allowed(current, saved_mask);
         return (result);
 }
 
@@ -270,30 +330,65 @@ acpi_cpufreq_guess_freq (
         struct cpufreq_acpi_io  *data,
         unsigned int            cpu)
 {
+        struct acpi_processor_performance       *perf = data->acpi_data;
+
         if (cpu_khz) {
                 /* search the closest match to cpu_khz */
                 unsigned int i;
                 unsigned long freq;
-                unsigned long freqn = data->acpi_data.states[0].core_frequency * 1000;
+                unsigned long freqn = perf->states[0].core_frequency * 1000;
 
-                for (i=0; i < (data->acpi_data.state_count - 1); i++) {
+                for (i = 0; i < (perf->state_count - 1); i++) {
                         freq = freqn;
-                        freqn = data->acpi_data.states[i+1].core_frequency * 1000;
+                        freqn = perf->states[i+1].core_frequency * 1000;
                         if ((2 * cpu_khz) > (freqn + freq)) {
-                                data->acpi_data.state = i;
+                                perf->state = i;
                                 return (freq);
                         }
                 }
-                data->acpi_data.state = data->acpi_data.state_count - 1;
+                perf->state = perf->state_count - 1;
                 return (freqn);
-        } else
+        } else {
                 /* assume CPU is at P0... */
-                data->acpi_data.state = 0;
-                return data->acpi_data.states[0].core_frequency * 1000;
-        
+                perf->state = 0;
+                return perf->states[0].core_frequency * 1000;
+        }
 }
 
 
+/*
+ * acpi_cpufreq_early_init - initialize ACPI P-States library
+ *
+ * Initialize the ACPI P-States library (drivers/acpi/processor_perflib.c)
+ * in order to determine correct frequency and voltage pairings. We can
+ * do _PDC and _PSD and find out the processor dependency for the
+ * actual init that will happen later...
+ */
+static int acpi_cpufreq_early_init_acpi(void)
+{
+        struct acpi_processor_performance       *data;
+        unsigned int                            i, j;
+
+        dprintk("acpi_cpufreq_early_init\n");
+
+        for_each_cpu(i) {
+                data = kzalloc(sizeof(struct acpi_processor_performance), 
+                        GFP_KERNEL);
+                if (!data) {
+                        for_each_cpu(j) {
+                                kfree(acpi_perf_data[j]);
+                                acpi_perf_data[j] = NULL;
+                        }
+                        return (-ENOMEM);
+                }
+                acpi_perf_data[i] = data;
+        }
+
+        /* Do initialization in ACPI core */
+        acpi_processor_preregister_performance(acpi_perf_data);
+        return 0;
+}
+
 static int
 acpi_cpufreq_cpu_init (
         struct cpufreq_policy   *policy)
@@ -303,41 +398,51 @@ acpi_cpufreq_cpu_init (
         struct cpufreq_acpi_io  *data;
         unsigned int            result = 0;
         struct cpuinfo_x86 *c = &cpu_data[policy->cpu];
+        struct acpi_processor_performance       *perf;
 
         dprintk("acpi_cpufreq_cpu_init\n");
 
+        if (!acpi_perf_data[cpu])
+                return (-ENODEV);
+
         data = kzalloc(sizeof(struct cpufreq_acpi_io), GFP_KERNEL);
         if (!data)
                 return (-ENOMEM);
 
+        data->acpi_data = acpi_perf_data[cpu];
         acpi_io_data[cpu] = data;
 
-        result = acpi_processor_register_performance(&data->acpi_data, cpu);
+        result = acpi_processor_register_performance(data->acpi_data, cpu);
 
         if (result)
                 goto err_free;
 
+        perf = data->acpi_data;
+        policy->cpus = perf->shared_cpu_map;
+        policy->shared_type = perf->shared_type;
+
         if (cpu_has(c, X86_FEATURE_CONSTANT_TSC)) {
                 acpi_cpufreq_driver.flags |= CPUFREQ_CONST_LOOPS;
         }
 
         /* capability check */
-        if (data->acpi_data.state_count <= 1) {
+        if (perf->state_count <= 1) {
                 dprintk("No P-States\n");
                 result = -ENODEV;
                 goto err_unreg;
         }
-        if ((data->acpi_data.control_register.space_id != ACPI_ADR_SPACE_SYSTEM_IO) ||
-            (data->acpi_data.status_register.space_id != ACPI_ADR_SPACE_SYSTEM_IO)) {
+
+        if ((perf->control_register.space_id != ACPI_ADR_SPACE_SYSTEM_IO) ||
+            (perf->status_register.space_id != ACPI_ADR_SPACE_SYSTEM_IO)) {
                 dprintk("Unsupported address space [%d, %d]\n",
-                        (u32) (data->acpi_data.control_register.space_id),
-                        (u32) (data->acpi_data.status_register.space_id));
+                        (u32) (perf->control_register.space_id),
+                        (u32) (perf->status_register.space_id));
                 result = -ENODEV;
                 goto err_unreg;
         }
 
         /* alloc freq_table */
-        data->freq_table = kmalloc(sizeof(struct cpufreq_frequency_table) * (data->acpi_data.state_count + 1), GFP_KERNEL);
+        data->freq_table = kmalloc(sizeof(struct cpufreq_frequency_table) * (perf->state_count + 1), GFP_KERNEL);
         if (!data->freq_table) {
                 result = -ENOMEM;
                 goto err_unreg;
@@ -345,9 +450,9 @@ acpi_cpufreq_cpu_init (
 
         /* detect transition latency */
         policy->cpuinfo.transition_latency = 0;
-        for (i=0; i<data->acpi_data.state_count; i++) {
-                if ((data->acpi_data.states[i].transition_latency * 1000) > policy->cpuinfo.transition_latency)
-                        policy->cpuinfo.transition_latency = data->acpi_data.states[i].transition_latency * 1000;
+        for (i=0; i<perf->state_count; i++) {
+                if ((perf->states[i].transition_latency * 1000) > policy->cpuinfo.transition_latency)
+                        policy->cpuinfo.transition_latency = perf->states[i].transition_latency * 1000;
         }
         policy->governor = CPUFREQ_DEFAULT_GOVERNOR;
 
@@ -355,11 +460,11 @@ acpi_cpufreq_cpu_init (
         policy->cur = acpi_cpufreq_guess_freq(data, policy->cpu);
 
         /* table init */
-        for (i=0; i<=data->acpi_data.state_count; i++)
+        for (i=0; i<=perf->state_count; i++)
         {
                 data->freq_table[i].index = i;
-                if (i<data->acpi_data.state_count)
-                        data->freq_table[i].frequency = data->acpi_data.states[i].core_frequency * 1000;
+                if (i<perf->state_count)
+                        data->freq_table[i].frequency = perf->states[i].core_frequency * 1000;
                 else
                         data->freq_table[i].frequency = CPUFREQ_TABLE_END;
         }
@@ -374,12 +479,12 @@ acpi_cpufreq_cpu_init (
 
         printk(KERN_INFO "acpi-cpufreq: CPU%u - ACPI performance management activated.\n",
                cpu);
-        for (i = 0; i < data->acpi_data.state_count; i++)
+        for (i = 0; i < perf->state_count; i++)
                 dprintk("     %cP%d: %d MHz, %d mW, %d uS\n",
-                        (i == data->acpi_data.state?'*':' '), i,
-                        (u32) data->acpi_data.states[i].core_frequency,
-                        (u32) data->acpi_data.states[i].power,
-                        (u32) data->acpi_data.states[i].transition_latency);
+                        (i == perf->state?'*':' '), i,
+                        (u32) perf->states[i].core_frequency,
+                        (u32) perf->states[i].power,
+                        (u32) perf->states[i].transition_latency);
 
         cpufreq_frequency_table_get_attr(data->freq_table, policy->cpu);
         
@@ -394,7 +499,7 @@ acpi_cpufreq_cpu_init (
  err_freqfree:
         kfree(data->freq_table);
  err_unreg:
-        acpi_processor_unregister_performance(&data->acpi_data, cpu);
+        acpi_processor_unregister_performance(perf, cpu);
  err_free:
         kfree(data);
         acpi_io_data[cpu] = NULL;
@@ -415,7 +520,7 @@ acpi_cpufreq_cpu_exit (
         if (data) {
                 cpufreq_frequency_table_put_attr(policy->cpu);
                 acpi_io_data[policy->cpu] = NULL;
-                acpi_processor_unregister_performance(&data->acpi_data, policy->cpu);
+                acpi_processor_unregister_performance(data->acpi_data, policy->cpu);
                 kfree(data);
         }
 
@@ -462,7 +567,10 @@ acpi_cpufreq_init (void)
 
         dprintk("acpi_cpufreq_init\n");
 
-        result = cpufreq_register_driver(&acpi_cpufreq_driver);
+        result = acpi_cpufreq_early_init_acpi();
+
+        if (!result)
+                result = cpufreq_register_driver(&acpi_cpufreq_driver);
         
         return (result);
 }
@@ -471,10 +579,15 @@ acpi_cpufreq_init (void)
 static void __exit
 acpi_cpufreq_exit (void)
 {
+        unsigned int    i;
         dprintk("acpi_cpufreq_exit\n");
 
         cpufreq_unregister_driver(&acpi_cpufreq_driver);
 
+        for_each_cpu(i) {
+                kfree(acpi_perf_data[i]);
+                acpi_perf_data[i] = NULL;
+        }
         return;
 }
 
diff --git a/arch/i386/kernel/cpu/cpufreq/powernow-k8.c b/arch/i386/kernel/cpu/cpufreq/powernow-k8.c
index b4277f58f40c..2d6491672559 100644
--- a/arch/i386/kernel/cpu/cpufreq/powernow-k8.c
+++ b/arch/i386/kernel/cpu/cpufreq/powernow-k8.c
@@ -120,7 +120,7 @@ static int pending_bit_stuck(void)
 {
         u32 lo, hi;
 
-        if (cpu_family)
+        if (cpu_family == CPU_HW_PSTATE)
                 return 0;
 
         rdmsr(MSR_FIDVID_STATUS, lo, hi);
@@ -136,7 +136,7 @@ static int query_current_values_with_pending_wait(struct powernow_k8_data *data)
         u32 lo, hi;
         u32 i = 0;
 
-        if (cpu_family) {
+        if (cpu_family == CPU_HW_PSTATE) {
                 rdmsr(MSR_PSTATE_STATUS, lo, hi);
                 i = lo & HW_PSTATE_MASK;
                 rdmsr(MSR_PSTATE_DEF_BASE + i, lo, hi);
@@ -598,7 +598,7 @@ static void print_basics(struct powernow_k8_data *data)
         int j;
         for (j = 0; j < data->numps; j++) {
                 if (data->powernow_table[j].frequency != CPUFREQ_ENTRY_INVALID) {
-                        if (cpu_family) {
+                        if (cpu_family == CPU_HW_PSTATE) {
                         printk(KERN_INFO PFX "   %d : fid 0x%x gid 0x%x (%d MHz)\n", j, (data->powernow_table[j].index & 0xff00) >> 8,
                                 (data->powernow_table[j].index & 0xff0000) >> 16,
                                 data->powernow_table[j].frequency/1000);
@@ -758,7 +758,7 @@ static int find_psb_table(struct powernow_k8_data *data)
 #ifdef CONFIG_X86_POWERNOW_K8_ACPI
 static void powernow_k8_acpi_pst_values(struct powernow_k8_data *data, unsigned int index)
 {
-        if (!data->acpi_data.state_count || cpu_family)
+        if (!data->acpi_data.state_count || (cpu_family == CPU_HW_PSTATE))
                 return;
 
         data->irt = (data->acpi_data.states[index].control >> IRT_SHIFT) & IRT_MASK;
@@ -801,7 +801,7 @@ static int powernow_k8_cpu_init_acpi(struct powernow_k8_data *data)
                 goto err_out;
         }
 
-        if (cpu_family)
+        if (cpu_family == CPU_HW_PSTATE)
                 ret_val = fill_powernow_table_pstate(data, powernow_table);
         else
                 ret_val = fill_powernow_table_fidvid(data, powernow_table);
@@ -885,8 +885,8 @@ static int fill_powernow_table_fidvid(struct powernow_k8_data *data, struct cpuf
                 u32 vid;
 
                 if (data->exttype) {
-                        fid = data->acpi_data.states[i].status & FID_MASK;
-                        vid = (data->acpi_data.states[i].status >> VID_SHIFT) & VID_MASK;
+                        fid = data->acpi_data.states[i].status & EXT_FID_MASK;
+                        vid = (data->acpi_data.states[i].status >> VID_SHIFT) & EXT_VID_MASK;
                 } else {
                         fid = data->acpi_data.states[i].control & FID_MASK;
                         vid = (data->acpi_data.states[i].control >> VID_SHIFT) & VID_MASK;
@@ -1082,7 +1082,7 @@ static int powernowk8_target(struct cpufreq_policy *pol, unsigned targfreq, unsi
         if (query_current_values_with_pending_wait(data))
                 goto err_out;
 
-        if (cpu_family)
+        if (cpu_family == CPU_HW_PSTATE)
                 dprintk("targ: curr fid 0x%x, did 0x%x\n",
                         data->currfid, data->currvid);
         else {
@@ -1103,7 +1103,7 @@ static int powernowk8_target(struct cpufreq_policy *pol, unsigned targfreq, unsi
 
         powernow_k8_acpi_pst_values(data, newstate);
 
-        if (cpu_family)
+        if (cpu_family == CPU_HW_PSTATE)
                 ret = transition_frequency_pstate(data, newstate);
         else
                 ret = transition_frequency_fidvid(data, newstate);
@@ -1115,7 +1115,7 @@ static int powernowk8_target(struct cpufreq_policy *pol, unsigned targfreq, unsi
         }
         mutex_unlock(&fidvid_mutex);
 
-        if (cpu_family)
+        if (cpu_family == CPU_HW_PSTATE)
                 pol->cur = find_khz_freq_from_fiddid(data->currfid, data->currdid);
         else
                 pol->cur = find_khz_freq_from_fid(data->currfid);
@@ -1163,7 +1163,7 @@ static int __cpuinit powernowk8_cpu_init(struct cpufreq_policy *pol)
                  * Use the PSB BIOS structure. This is only availabe on
                  * an UP version, and is deprecated by AMD.
                  */
-                if ((num_online_cpus() != 1) || (num_possible_cpus() != 1)) {
+                if (num_online_cpus() != 1) {
                         printk(KERN_ERR PFX "MP systems not supported by PSB BIOS structure\n");
                         kfree(data);
                         return -ENODEV;
@@ -1197,14 +1197,14 @@ static int __cpuinit powernowk8_cpu_init(struct cpufreq_policy *pol)
         if (query_current_values_with_pending_wait(data))
                 goto err_out;
 
-        if (!cpu_family)
+        if (cpu_family == CPU_OPTERON)
                 fidvid_msr_init();
 
         /* run on any CPU again */
         set_cpus_allowed(current, oldmask);
 
         pol->governor = CPUFREQ_DEFAULT_GOVERNOR;
-        if (cpu_family)
+        if (cpu_family == CPU_HW_PSTATE)
                 pol->cpus = cpumask_of_cpu(pol->cpu);
         else
                 pol->cpus = cpu_core_map[pol->cpu];
@@ -1215,7 +1215,7 @@ static int __cpuinit powernowk8_cpu_init(struct cpufreq_policy *pol)
         pol->cpuinfo.transition_latency = (((data->rvo + 8) * data->vstable * VST_UNITS_20US)
             + (3 * (1 << data->irt) * 10)) * 1000;
 
-        if (cpu_family)
+        if (cpu_family == CPU_HW_PSTATE)
                 pol->cur = find_khz_freq_from_fiddid(data->currfid, data->currdid);
         else
                 pol->cur = find_khz_freq_from_fid(data->currfid);
@@ -1232,7 +1232,7 @@ static int __cpuinit powernowk8_cpu_init(struct cpufreq_policy *pol)
 
         cpufreq_frequency_table_get_attr(data->powernow_table, pol->cpu);
 
-        if (cpu_family)
+        if (cpu_family == CPU_HW_PSTATE)
                 dprintk("cpu_init done, current fid 0x%x, did 0x%x\n",
                         data->currfid, data->currdid);
         else
diff --git a/arch/i386/kernel/cpu/cpufreq/powernow-k8.h b/arch/i386/kernel/cpu/cpufreq/powernow-k8.h
index bf8ad9e43da3..0fb2a3001ba5 100644
--- a/arch/i386/kernel/cpu/cpufreq/powernow-k8.h
+++ b/arch/i386/kernel/cpu/cpufreq/powernow-k8.h
@@ -169,7 +169,9 @@ struct powernow_k8_data {
 #define MVS_MASK        3
 #define VST_MASK     0x7f
 #define VID_MASK     0x1f
-#define FID_MASK     0x3f
+#define FID_MASK     0x1f
+#define EXT_VID_MASK 0x3f
+#define EXT_FID_MASK 0x3f
 
 
 /*
diff --git a/arch/i386/kernel/cpu/cpufreq/speedstep-centrino.c b/arch/i386/kernel/cpu/cpufreq/speedstep-centrino.c
index ce54ff12c15d..31c3a5baaa7f 100644
--- a/arch/i386/kernel/cpu/cpufreq/speedstep-centrino.c
+++ b/arch/i386/kernel/cpu/cpufreq/speedstep-centrino.c
@@ -2,19 +2,15 @@
  * cpufreq driver for Enhanced SpeedStep, as found in Intel's Pentium
  * M (part of the Centrino chipset).
  *
+ * Since the original Pentium M, most new Intel CPUs support Enhanced
+ * SpeedStep.
+ *
  * Despite the "SpeedStep" in the name, this is almost entirely unlike
  * traditional SpeedStep.
  *
  * Modelled on speedstep.c
  *
  * Copyright (C) 2003 Jeremy Fitzhardinge <jeremy@goop.org>
- *
- * WARNING WARNING WARNING
- *
- * This driver manipulates the PERF_CTL MSR, which is only somewhat
- * documented.  While it seems to work on my laptop, it has not been
- * tested anywhere else, and it may not work for you, do strange
- * things or simply crash.
  */
 
 #include <linux/kernel.h>
@@ -36,7 +32,7 @@
 #include <asm/cpufeature.h>
 
 #define PFX             "speedstep-centrino: "
-#define MAINTAINER      "Jeremy Fitzhardinge <jeremy@goop.org>"
+#define MAINTAINER      "cpufreq@lists.linux.org.uk"
 
 #define dprintk(msg...) cpufreq_debug_printk(CPUFREQ_DEBUG_DRIVER, "speedstep-centrino", msg)
 
@@ -351,7 +347,36 @@ static unsigned int get_cur_freq(unsigned int cpu)
 
 #ifdef CONFIG_X86_SPEEDSTEP_CENTRINO_ACPI
 
-static struct acpi_processor_performance p;
+static struct acpi_processor_performance *acpi_perf_data[NR_CPUS];
+
+/*
+ * centrino_cpu_early_init_acpi - Do the preregistering with ACPI P-States
+ * library
+ *
+ * Before doing the actual init, we need to do _PSD related setup whenever
+ * supported by the BIOS. These are handled by this early_init routine.
+ */
+static int centrino_cpu_early_init_acpi(void)
+{
+        unsigned int    i, j;
+        struct acpi_processor_performance       *data;
+
+        for_each_cpu(i) {
+                data = kzalloc(sizeof(struct acpi_processor_performance), 
+                                GFP_KERNEL);
+                if (!data) {
+                        for_each_cpu(j) {
+                                kfree(acpi_perf_data[j]);
+                                acpi_perf_data[j] = NULL;
+                        }
+                        return (-ENOMEM);
+                }
+                acpi_perf_data[i] = data;
+        }
+
+        acpi_processor_preregister_performance(acpi_perf_data);
+        return 0;
+}
 
 /*
  * centrino_cpu_init_acpi - register with ACPI P-States library
@@ -365,46 +390,51 @@ static int centrino_cpu_init_acpi(struct cpufreq_policy *policy)
         unsigned long                   cur_freq;
         int                             result = 0, i;
         unsigned int                    cpu = policy->cpu;
+        struct acpi_processor_performance       *p;
+
+        p = acpi_perf_data[cpu];
 
         /* register with ACPI core */
-        if (acpi_processor_register_performance(&p, cpu)) {
-                dprintk("obtaining ACPI data failed\n");
+        if (acpi_processor_register_performance(p, cpu)) {
+                dprintk(PFX "obtaining ACPI data failed\n");
                 return -EIO;
         }
+        policy->cpus = p->shared_cpu_map;
+        policy->shared_type = p->shared_type;
 
         /* verify the acpi_data */
-        if (p.state_count <= 1) {
+        if (p->state_count <= 1) {
                 dprintk("No P-States\n");
                 result = -ENODEV;
                 goto err_unreg;
         }
 
-        if ((p.control_register.space_id != ACPI_ADR_SPACE_FIXED_HARDWARE) ||
-            (p.status_register.space_id != ACPI_ADR_SPACE_FIXED_HARDWARE)) {
+        if ((p->control_register.space_id != ACPI_ADR_SPACE_FIXED_HARDWARE) ||
+            (p->status_register.space_id != ACPI_ADR_SPACE_FIXED_HARDWARE)) {
                 dprintk("Invalid control/status registers (%x - %x)\n",
-                        p.control_register.space_id, p.status_register.space_id);
+                        p->control_register.space_id, p->status_register.space_id);
                 result = -EIO;
                 goto err_unreg;
         }
 
-        for (i=0; i<p.state_count; i++) {
-                if (p.states[i].control != p.states[i].status) {
+        for (i=0; i<p->state_count; i++) {
+                if (p->states[i].control != p->states[i].status) {
                         dprintk("Different control (%llu) and status values (%llu)\n",
-                                p.states[i].control, p.states[i].status);
+                                p->states[i].control, p->states[i].status);
                         result = -EINVAL;
                         goto err_unreg;
                 }
 
-                if (!p.states[i].core_frequency) {
+                if (!p->states[i].core_frequency) {
                         dprintk("Zero core frequency for state %u\n", i);
                         result = -EINVAL;
                         goto err_unreg;
                 }
 
-                if (p.states[i].core_frequency > p.states[0].core_frequency) {
+                if (p->states[i].core_frequency > p->states[0].core_frequency) {
                         dprintk("P%u has larger frequency (%llu) than P0 (%llu), skipping\n", i,
-                                p.states[i].core_frequency, p.states[0].core_frequency);
-                        p.states[i].core_frequency = 0;
+                                p->states[i].core_frequency, p->states[0].core_frequency);
+                        p->states[i].core_frequency = 0;
                         continue;
                 }
         }
@@ -416,26 +446,26 @@ static int centrino_cpu_init_acpi(struct cpufreq_policy *policy)
         }
 
         centrino_model[cpu]->model_name=NULL;
-        centrino_model[cpu]->max_freq = p.states[0].core_frequency * 1000;
+        centrino_model[cpu]->max_freq = p->states[0].core_frequency * 1000;
         centrino_model[cpu]->op_points =  kmalloc(sizeof(struct cpufreq_frequency_table) *
-                                             (p.state_count + 1), GFP_KERNEL);
+                                             (p->state_count + 1), GFP_KERNEL);
         if (!centrino_model[cpu]->op_points) {
                 result = -ENOMEM;
                 goto err_kfree;
         }
 
-        for (i=0; i<p.state_count; i++) {
-                centrino_model[cpu]->op_points[i].index = p.states[i].control;
-                centrino_model[cpu]->op_points[i].frequency = p.states[i].core_frequency * 1000;
+        for (i=0; i<p->state_count; i++) {
+                centrino_model[cpu]->op_points[i].index = p->states[i].control;
+                centrino_model[cpu]->op_points[i].frequency = p->states[i].core_frequency * 1000;
                 dprintk("adding state %i with frequency %u and control value %04x\n", 
                         i, centrino_model[cpu]->op_points[i].frequency, centrino_model[cpu]->op_points[i].index);
         }
-        centrino_model[cpu]->op_points[p.state_count].frequency = CPUFREQ_TABLE_END;
+        centrino_model[cpu]->op_points[p->state_count].frequency = CPUFREQ_TABLE_END;
 
         cur_freq = get_cur_freq(cpu);
 
-        for (i=0; i<p.state_count; i++) {
-                if (!p.states[i].core_frequency) {
+        for (i=0; i<p->state_count; i++) {
+                if (!p->states[i].core_frequency) {
                         dprintk("skipping state %u\n", i);
                         centrino_model[cpu]->op_points[i].frequency = CPUFREQ_ENTRY_INVALID;
                         continue;
@@ -451,7 +481,7 @@ static int centrino_cpu_init_acpi(struct cpufreq_policy *policy)
                 }
 
                 if (cur_freq == centrino_model[cpu]->op_points[i].frequency)
-                        p.state = i;
+                        p->state = i;
         }
 
         /* notify BIOS that we exist */
@@ -464,12 +494,13 @@ static int centrino_cpu_init_acpi(struct cpufreq_policy *policy)
  err_kfree:
         kfree(centrino_model[cpu]);
  err_unreg:
-        acpi_processor_unregister_performance(&p, cpu);
-        dprintk("invalid ACPI data\n");
+        acpi_processor_unregister_performance(p, cpu);
+        dprintk(PFX "invalid ACPI data\n");
         return (result);
 }
 #else
 static inline int centrino_cpu_init_acpi(struct cpufreq_policy *policy) { return -ENODEV; }
+static inline int centrino_cpu_early_init_acpi(void) { return 0; }
 #endif
 
 static int centrino_cpu_init(struct cpufreq_policy *policy)
@@ -555,10 +586,15 @@ static int centrino_cpu_exit(struct cpufreq_policy *policy)
 
 #ifdef CONFIG_X86_SPEEDSTEP_CENTRINO_ACPI
         if (!centrino_model[cpu]->model_name) {
-                dprintk("unregistering and freeing ACPI data\n");
-                acpi_processor_unregister_performance(&p, cpu);
-                kfree(centrino_model[cpu]->op_points);
-                kfree(centrino_model[cpu]);
+                static struct acpi_processor_performance *p;
+
+                if (acpi_perf_data[cpu]) {
+                        p = acpi_perf_data[cpu];
+                        dprintk("unregistering and freeing ACPI data\n");
+                        acpi_processor_unregister_performance(p, cpu);
+                        kfree(centrino_model[cpu]->op_points);
+                        kfree(centrino_model[cpu]);
+                }
         }
 #endif
 
@@ -592,63 +628,128 @@ static int centrino_target (struct cpufreq_policy *policy,
                             unsigned int relation)
 {
         unsigned int    newstate = 0;
-        unsigned int    msr, oldmsr, h, cpu = policy->cpu;
+        unsigned int    msr, oldmsr = 0, h = 0, cpu = policy->cpu;
         struct cpufreq_freqs    freqs;
+        cpumask_t               online_policy_cpus;
         cpumask_t               saved_mask;
-        int                     retval;
+        cpumask_t               set_mask;
+        cpumask_t               covered_cpus;
+        int                     retval = 0;
+        unsigned int            j, k, first_cpu, tmp;
 
-        if (centrino_model[cpu] == NULL)
+        if (unlikely(centrino_model[cpu] == NULL))
                 return -ENODEV;
 
-        /*
-         * Support for SMP systems.
-         * Make sure we are running on the CPU that wants to change frequency
-         */
-        saved_mask = current->cpus_allowed;
-        set_cpus_allowed(current, policy->cpus);
-        if (!cpu_isset(smp_processor_id(), policy->cpus)) {
-                dprintk("couldn't limit to CPUs in this domain\n");
-                return(-EAGAIN);
+        if (unlikely(cpufreq_frequency_table_target(policy,
+                        centrino_model[cpu]->op_points,
+                        target_freq,
+                        relation,
+                        &newstate))) {
+                return -EINVAL;
         }
 
-        if (cpufreq_frequency_table_target(policy, centrino_model[cpu]->op_points, target_freq,
-                                           relation, &newstate)) {
-                retval = -EINVAL;
-                goto migrate_end;
-        }
+#ifdef CONFIG_HOTPLUG_CPU
+        /* cpufreq holds the hotplug lock, so we are safe from here on */
+        cpus_and(online_policy_cpus, cpu_online_map, policy->cpus);
+#else
+        online_policy_cpus = policy->cpus;
+#endif
 
-        msr = centrino_model[cpu]->op_points[newstate].index;
-        rdmsr(MSR_IA32_PERF_CTL, oldmsr, h);
+        saved_mask = current->cpus_allowed;
+        first_cpu = 1;
+        cpus_clear(covered_cpus);
+        for_each_cpu_mask(j, online_policy_cpus) {
+                /*
+                 * Support for SMP systems.
+                 * Make sure we are running on CPU that wants to change freq
+                 */
+                cpus_clear(set_mask);
+                if (policy->shared_type == CPUFREQ_SHARED_TYPE_ANY)
+                        cpus_or(set_mask, set_mask, online_policy_cpus);
+                else
+                        cpu_set(j, set_mask);
+
+                set_cpus_allowed(current, set_mask);
+                if (unlikely(!cpu_isset(smp_processor_id(), set_mask))) {
+                        dprintk("couldn't limit to CPUs in this domain\n");
+                        retval = -EAGAIN;
+                        if (first_cpu) {
+                                /* We haven't started the transition yet. */
+                                goto migrate_end;
+                        }
+                        break;
+                }
 
-        if (msr == (oldmsr & 0xffff)) {
-                retval = 0;
-                dprintk("no change needed - msr was and needs to be %x\n", oldmsr);
-                goto migrate_end;
-        }
+                msr = centrino_model[cpu]->op_points[newstate].index;
+
+                if (first_cpu) {
+                        rdmsr(MSR_IA32_PERF_CTL, oldmsr, h);
+                        if (msr == (oldmsr & 0xffff)) {
+                                dprintk("no change needed - msr was and needs "
+                                        "to be %x\n", oldmsr);
+                                retval = 0;
+                                goto migrate_end;
+                        }
+
+                        freqs.old = extract_clock(oldmsr, cpu, 0);
+                        freqs.new = extract_clock(msr, cpu, 0);
+
+                        dprintk("target=%dkHz old=%d new=%d msr=%04x\n",
+                                target_freq, freqs.old, freqs.new, msr);
+
+                        for_each_cpu_mask(k, online_policy_cpus) {
+                                freqs.cpu = k;
+                                cpufreq_notify_transition(&freqs,
+                                        CPUFREQ_PRECHANGE);
+                        }
+
+                        first_cpu = 0;
+                        /* all but 16 LSB are reserved, treat them with care */
+                        oldmsr &= ~0xffff;
+                        msr &= 0xffff;
+                        oldmsr |= msr;
+                }
 
-        freqs.cpu = cpu;
-        freqs.old = extract_clock(oldmsr, cpu, 0);
-        freqs.new = extract_clock(msr, cpu, 0);
+                wrmsr(MSR_IA32_PERF_CTL, oldmsr, h);
+                if (policy->shared_type == CPUFREQ_SHARED_TYPE_ANY)
+                        break;
 
-        dprintk("target=%dkHz old=%d new=%d msr=%04x\n",
-                target_freq, freqs.old, freqs.new, msr);
+                cpu_set(j, covered_cpus);
+        }
 
-        cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
+        for_each_cpu_mask(k, online_policy_cpus) {
+                freqs.cpu = k;
+                cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
+        }
 
-        /* all but 16 LSB are "reserved", so treat them with
-           care */
-        oldmsr &= ~0xffff;
-        msr &= 0xffff;
-        oldmsr |= msr;
+        if (unlikely(retval)) {
+                /*
+                 * We have failed halfway through the frequency change.
+                 * We have sent callbacks to policy->cpus and
+                 * MSRs have already been written on coverd_cpus.
+                 * Best effort undo..
+                 */
 
-        wrmsr(MSR_IA32_PERF_CTL, oldmsr, h);
+                if (!cpus_empty(covered_cpus)) {
+                        for_each_cpu_mask(j, covered_cpus) {
+                                set_cpus_allowed(current, cpumask_of_cpu(j));
+                                wrmsr(MSR_IA32_PERF_CTL, oldmsr, h);
+                        }
+                }
 
-        cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
+                tmp = freqs.new;
+                freqs.new = freqs.old;
+                freqs.old = tmp;
+                for_each_cpu_mask(j, online_policy_cpus) {
+                        freqs.cpu = j;
+                        cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
+                        cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
+                }
+        }
 
-        retval = 0;
 migrate_end:
         set_cpus_allowed(current, saved_mask);
-        return (retval);
+        return 0;
 }
 
 static struct freq_attr* centrino_attr[] = {
@@ -690,12 +791,25 @@ static int __init centrino_init(void)
         if (!cpu_has(cpu, X86_FEATURE_EST))
                 return -ENODEV;
 
+        centrino_cpu_early_init_acpi();
+
         return cpufreq_register_driver(&centrino_driver);
 }
 
 static void __exit centrino_exit(void)
 {
+#ifdef CONFIG_X86_SPEEDSTEP_CENTRINO_ACPI
+        unsigned int j;
+#endif
+        
         cpufreq_unregister_driver(&centrino_driver);
+
+#ifdef CONFIG_X86_SPEEDSTEP_CENTRINO_ACPI
+        for_each_cpu(j) {
+                kfree(acpi_perf_data[j]);
+                acpi_perf_data[j] = NULL;
+        }
+#endif
 }
 
 MODULE_AUTHOR ("Jeremy Fitzhardinge <jeremy@goop.org>");
diff --git a/arch/i386/kernel/cpu/cyrix.c b/arch/i386/kernel/cpu/cyrix.c
index 00f2e058797c..fc32c8028e24 100644
--- a/arch/i386/kernel/cpu/cyrix.c
+++ b/arch/i386/kernel/cpu/cyrix.c
@@ -184,7 +184,7 @@ static void __init geode_configure(void)
 
 
 #ifdef CONFIG_PCI
-static struct pci_device_id cyrix_55x0[] = {
+static struct pci_device_id __initdata cyrix_55x0[] = {
         { PCI_DEVICE(PCI_VENDOR_ID_CYRIX, PCI_DEVICE_ID_CYRIX_5510) },
         { PCI_DEVICE(PCI_VENDOR_ID_CYRIX, PCI_DEVICE_ID_CYRIX_5520) },
         { },
@@ -272,14 +272,15 @@ static void __init init_cyrix(struct cpuinfo_x86 *c)
 
                 printk(KERN_INFO "Working around Cyrix MediaGX virtual DMA bugs.\n");
                 isa_dma_bridge_buggy = 2;
-#endif          
-                c->x86_cache_size=16;   /* Yep 16K integrated cache thats it */
- 
+
+
                 /*
                  *  The 5510/5520 companion chips have a funky PIT.
                  */  
                 if (pci_dev_present(cyrix_55x0))
                         pit_latch_buggy = 1;
+#endif
+                c->x86_cache_size=16;   /* Yep 16K integrated cache thats it */
 
                 /* GXm supports extended cpuid levels 'ala' AMD */
                 if (c->cpuid_level == 2) {
diff --git a/arch/i386/kernel/cpu/proc.c b/arch/i386/kernel/cpu/proc.c
index f94cdb7aca50..a19fcb262dbb 100644
--- a/arch/i386/kernel/cpu/proc.c
+++ b/arch/i386/kernel/cpu/proc.c
@@ -52,7 +52,7 @@ static int show_cpuinfo(struct seq_file *m, void *v)
 
                 /* VIA/Cyrix/Centaur-defined */
                 NULL, NULL, "rng", "rng_en", NULL, NULL, "ace", "ace_en",
-                NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+                "ace2", "ace2_en", "phe", "phe_en", "pmm", "pmm_en", NULL, NULL,
                 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
                 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
 
diff --git a/arch/i386/kernel/i387.c b/arch/i386/kernel/i387.c
index d75524758daf..c4351972d9af 100644
--- a/arch/i386/kernel/i387.c
+++ b/arch/i386/kernel/i387.c
@@ -25,7 +25,7 @@
 #define HAVE_HWFP 1
 #endif
 
-static unsigned long mxcsr_feature_mask = 0xffffffff;
+static unsigned long mxcsr_feature_mask __read_mostly = 0xffffffff;
 
 void mxcsr_feature_mask_init(void)
 {
diff --git a/arch/i386/kernel/i8259.c b/arch/i386/kernel/i8259.c
index 323ef8ab3244..b7636b96e104 100644
--- a/arch/i386/kernel/i8259.c
+++ b/arch/i386/kernel/i8259.c
@@ -271,8 +271,8 @@ static int i8259A_shutdown(struct sys_device *dev)
          * the kernel initialization code can get it
          * out of.
          */
-        outb(0xff, 0x21);       /* mask all of 8259A-1 */
-        outb(0xff, 0xA1);       /* mask all of 8259A-1 */
+        outb(0xff, PIC_MASTER_IMR);     /* mask all of 8259A-1 */
+        outb(0xff, PIC_SLAVE_IMR);      /* mask all of 8259A-1 */
         return 0;
 }
 
diff --git a/arch/i386/kernel/io_apic.c b/arch/i386/kernel/io_apic.c
index d70f2ade5cde..a62df3e764c5 100644
--- a/arch/i386/kernel/io_apic.c
+++ b/arch/i386/kernel/io_apic.c
@@ -267,7 +267,7 @@ static void set_ioapic_affinity_irq(unsigned int irq, cpumask_t cpumask)
 # include <linux/slab.h>                /* kmalloc() */
 # include <linux/timer.h>       /* time_after() */
  
-# ifdef CONFIG_BALANCED_IRQ_DEBUG
+#ifdef CONFIG_BALANCED_IRQ_DEBUG
 #  define TDprintk(x...) do { printk("<%ld:%s:%d>: ", jiffies, __FILE__, __LINE__); printk(x); } while (0)
 #  define Dprintk(x...) do { TDprintk(x); } while (0)
 # else
@@ -275,10 +275,15 @@ static void set_ioapic_affinity_irq(unsigned int irq, cpumask_t cpumask)
 #  define Dprintk(x...) 
 # endif
 
-
 #define IRQBALANCE_CHECK_ARCH -999
-static int irqbalance_disabled = IRQBALANCE_CHECK_ARCH;
-static int physical_balance = 0;
+#define MAX_BALANCED_IRQ_INTERVAL       (5*HZ)
+#define MIN_BALANCED_IRQ_INTERVAL       (HZ/2)
+#define BALANCED_IRQ_MORE_DELTA         (HZ/10)
+#define BALANCED_IRQ_LESS_DELTA         (HZ)
+
+static int irqbalance_disabled __read_mostly = IRQBALANCE_CHECK_ARCH;
+static int physical_balance __read_mostly;
+static long balanced_irq_interval __read_mostly = MAX_BALANCED_IRQ_INTERVAL;
 
 static struct irq_cpu_info {
         unsigned long * last_irq;
@@ -297,12 +302,14 @@ static struct irq_cpu_info {
 
 #define CPU_TO_PACKAGEINDEX(i) (first_cpu(cpu_sibling_map[i]))
 
-#define MAX_BALANCED_IRQ_INTERVAL       (5*HZ)
-#define MIN_BALANCED_IRQ_INTERVAL       (HZ/2)
-#define BALANCED_IRQ_MORE_DELTA         (HZ/10)
-#define BALANCED_IRQ_LESS_DELTA         (HZ)
+static cpumask_t balance_irq_affinity[NR_IRQS] = {
+        [0 ... NR_IRQS-1] = CPU_MASK_ALL
+};
 
-static long balanced_irq_interval = MAX_BALANCED_IRQ_INTERVAL;
+void set_balance_irq_affinity(unsigned int irq, cpumask_t mask)
+{
+        balance_irq_affinity[irq] = mask;
+}
 
 static unsigned long move(int curr_cpu, cpumask_t allowed_mask,
                         unsigned long now, int direction)
@@ -340,7 +347,7 @@ static inline void balance_irq(int cpu, int irq)
         if (irqbalance_disabled)
                 return; 
 
-        cpus_and(allowed_mask, cpu_online_map, irq_affinity[irq]);
+        cpus_and(allowed_mask, cpu_online_map, balance_irq_affinity[irq]);
         new_cpu = move(cpu, allowed_mask, now, 1);
         if (cpu != new_cpu) {
                 set_pending_irq(irq, cpumask_of_cpu(new_cpu));
@@ -529,7 +536,9 @@ tryanotherirq:
                 }
         }
 
-        cpus_and(allowed_mask, cpu_online_map, irq_affinity[selected_irq]);
+        cpus_and(allowed_mask,
+                cpu_online_map,
+                balance_irq_affinity[selected_irq]);
         target_cpu_mask = cpumask_of_cpu(min_loaded);
         cpus_and(tmp, target_cpu_mask, allowed_mask);
 
diff --git a/arch/i386/kernel/irq.c b/arch/i386/kernel/irq.c
index f3a9c78c4a24..248e922ee13a 100644
--- a/arch/i386/kernel/irq.c
+++ b/arch/i386/kernel/irq.c
@@ -42,8 +42,8 @@ union irq_ctx {
         u32                     stack[THREAD_SIZE/sizeof(u32)];
 };
 
-static union irq_ctx *hardirq_ctx[NR_CPUS];
-static union irq_ctx *softirq_ctx[NR_CPUS];
+static union irq_ctx *hardirq_ctx[NR_CPUS] __read_mostly;
+static union irq_ctx *softirq_ctx[NR_CPUS] __read_mostly;
 #endif
 
 /*
diff --git a/arch/i386/kernel/kprobes.c b/arch/i386/kernel/kprobes.c
index 38806f427849..395a9a6dff88 100644
--- a/arch/i386/kernel/kprobes.c
+++ b/arch/i386/kernel/kprobes.c
@@ -607,7 +607,7 @@ int __kprobes kprobe_exceptions_notify(struct notifier_block *self,
         struct die_args *args = (struct die_args *)data;
         int ret = NOTIFY_DONE;
 
-        if (args->regs && user_mode(args->regs))
+        if (args->regs && user_mode_vm(args->regs))
                 return ret;
 
         switch (val) {
diff --git a/arch/i386/kernel/microcode.c b/arch/i386/kernel/microcode.c
index e7c138f66c5a..0a865889b2a9 100644
--- a/arch/i386/kernel/microcode.c
+++ b/arch/i386/kernel/microcode.c
@@ -91,7 +91,10 @@ MODULE_DESCRIPTION("Intel CPU (IA-32) Microcode Update Driver");
 MODULE_AUTHOR("Tigran Aivazian <tigran@veritas.com>");
 MODULE_LICENSE("GPL");
 
-#define MICROCODE_VERSION       "1.14"
+static int verbose;
+module_param(verbose, int, 0644);
+
+#define MICROCODE_VERSION       "1.14a"
 
 #define DEFAULT_UCODE_DATASIZE  (2000)    /* 2000 bytes */
 #define MC_HEADER_SIZE          (sizeof (microcode_header_t))     /* 48 bytes */
@@ -122,14 +125,15 @@ static unsigned int user_buffer_size;	/* it's size */
 
 typedef enum mc_error_code {
         MC_SUCCESS      = 0,
-        MC_NOTFOUND     = 1,
-        MC_MARKED       = 2,
-        MC_ALLOCATED    = 3,
+        MC_IGNORED      = 1,
+        MC_NOTFOUND     = 2,
+        MC_MARKED       = 3,
+        MC_ALLOCATED    = 4,
 } mc_error_code_t;
 
 static struct ucode_cpu_info {
         unsigned int sig;
-        unsigned int pf;
+        unsigned int pf, orig_pf;
         unsigned int rev;
         unsigned int cksum;
         mc_error_code_t err;
@@ -164,6 +168,7 @@ static void collect_cpu_info (void *unused)
                         rdmsr(MSR_IA32_PLATFORM_ID, val[0], val[1]);
                         uci->pf = 1 << ((val[1] >> 18) & 7);
                 }
+                uci->orig_pf = uci->pf;
         }
 
         wrmsr(MSR_IA32_UCODE_REV, 0, 0);
@@ -197,21 +202,34 @@ static inline void mark_microcode_update (int cpu_num, microcode_header_t *mc_he
         pr_debug("   Checksum 0x%x\n", cksum);
 
         if (mc_header->rev < uci->rev) {
-                printk(KERN_ERR "microcode: CPU%d not 'upgrading' to earlier revision"
-                       " 0x%x (current=0x%x)\n", cpu_num, mc_header->rev, uci->rev);
-                goto out;
+                if (uci->err == MC_NOTFOUND) {
+                        uci->err = MC_IGNORED;
+                        uci->cksum = mc_header->rev;
+                } else if (uci->err == MC_IGNORED && uci->cksum < mc_header->rev)
+                        uci->cksum = mc_header->rev;
         } else if (mc_header->rev == uci->rev) {
-                /* notify the caller of success on this cpu */
-                uci->err = MC_SUCCESS;
-                goto out;
+                if (uci->err < MC_MARKED) {
+                        /* notify the caller of success on this cpu */
+                        uci->err = MC_SUCCESS;
+                }
+        } else if (uci->err != MC_ALLOCATED || mc_header->rev > uci->mc->hdr.rev) {
+                pr_debug("microcode: CPU%d found a matching microcode update with "
+                        " revision 0x%x (current=0x%x)\n", cpu_num, mc_header->rev, uci->rev);
+                uci->cksum = cksum;
+                uci->pf = pf; /* keep the original mc pf for cksum calculation */
+                uci->err = MC_MARKED; /* found the match */
+                for_each_online_cpu(cpu_num) {
+                        if (ucode_cpu_info + cpu_num != uci
+                            && ucode_cpu_info[cpu_num].mc == uci->mc) {
+                                uci->mc = NULL;
+                                break;
+                        }
+                }
+                if (uci->mc != NULL) {
+                        vfree(uci->mc);
+                        uci->mc = NULL;
+                }
         }
-
-        pr_debug("microcode: CPU%d found a matching microcode update with "
-                " revision 0x%x (current=0x%x)\n", cpu_num, mc_header->rev, uci->rev);
-        uci->cksum = cksum;
-        uci->pf = pf; /* keep the original mc pf for cksum calculation */
-        uci->err = MC_MARKED; /* found the match */
-out:
         return;
 }
 
@@ -253,10 +271,8 @@ static int find_matching_ucodes (void)
 
                 for_each_online_cpu(cpu_num) {
                         struct ucode_cpu_info *uci = ucode_cpu_info + cpu_num;
-                        if (uci->err != MC_NOTFOUND) /* already found a match or not an online cpu*/
-                                continue;
 
-                        if (sigmatch(mc_header.sig, uci->sig, mc_header.pf, uci->pf))
+                        if (sigmatch(mc_header.sig, uci->sig, mc_header.pf, uci->orig_pf))
                                 mark_microcode_update(cpu_num, &mc_header, mc_header.sig, mc_header.pf, mc_header.cksum);
                 }
 
@@ -295,9 +311,8 @@ static int find_matching_ucodes (void)
                                 }
                                 for_each_online_cpu(cpu_num) {
                                         struct ucode_cpu_info *uci = ucode_cpu_info + cpu_num;
-                                        if (uci->err != MC_NOTFOUND) /* already found a match or not an online cpu*/
-                                                continue;
-                                        if (sigmatch(ext_sig.sig, uci->sig, ext_sig.pf, uci->pf)) {
+
+                                        if (sigmatch(ext_sig.sig, uci->sig, ext_sig.pf, uci->orig_pf)) {
                                                 mark_microcode_update(cpu_num, &mc_header, ext_sig.sig, ext_sig.pf, ext_sig.cksum);
                                         }
                                 }
@@ -368,6 +383,13 @@ static void do_update_one (void * unused)
         struct ucode_cpu_info *uci = ucode_cpu_info + cpu_num;
 
         if (uci->mc == NULL) {
+                if (verbose) {
+                        if (uci->err == MC_SUCCESS)
+                                printk(KERN_INFO "microcode: CPU%d already at revision 0x%x\n",
+                                        cpu_num, uci->rev);
+                        else
+                                printk(KERN_INFO "microcode: No new microcode data for CPU%d\n", cpu_num);
+                }
                 return;
         }
 
@@ -426,6 +448,9 @@ out_free:
                                         ucode_cpu_info[j].mc = NULL;
                         }
                 }
+                if (ucode_cpu_info[i].err == MC_IGNORED && verbose)
+                        printk(KERN_WARNING "microcode: CPU%d not 'upgrading' to earlier revision"
+                               " 0x%x (current=0x%x)\n", i, ucode_cpu_info[i].cksum, ucode_cpu_info[i].rev);
         }
 out:
         return error;
diff --git a/arch/i386/kernel/setup.c b/arch/i386/kernel/setup.c
index dd6b0e3386ce..e6023970aa40 100644
--- a/arch/i386/kernel/setup.c
+++ b/arch/i386/kernel/setup.c
@@ -48,6 +48,7 @@
 #include <linux/crash_dump.h>
 #include <linux/dmi.h>
 #include <linux/pfn.h>
+#include <linux/suspend.h>
 
 #include <video/edid.h>
 
@@ -1434,6 +1435,111 @@ static void set_mca_bus(int x)
 static void set_mca_bus(int x) { }
 #endif
 
+#ifdef CONFIG_SOFTWARE_SUSPEND
+static void __init mark_nosave_page_range(unsigned long start, unsigned long end)
+{
+        struct page *page;
+        while (start <= end) {
+                page = pfn_to_page(start);
+                SetPageNosave(page);
+                start++;
+        }
+}
+
+static void __init e820_nosave_reserved_pages(void)
+{
+        int i;
+        unsigned long r_start = 0, r_end = 0;
+
+        /* Assume e820 map is sorted */
+        for (i = 0; i < e820.nr_map; i++) {
+                struct e820entry *ei = &e820.map[i];
+                unsigned long start, end;
+
+                start = PFN_DOWN(ei->addr);
+                end = PFN_UP(ei->addr + ei->size);
+                if (start >= end)
+                        continue;
+                if (ei->type == E820_RESERVED)
+                        continue;
+                r_end = start;
+                /*
+                 * Highmem 'Reserved' pages are marked as reserved, swsusp
+                 * will not save/restore them, so we ignore these pages here.
+                 */
+                if (r_end > max_low_pfn)
+                        r_end = max_low_pfn;
+                if (r_end > r_start)
+                        mark_nosave_page_range(r_start, r_end-1);
+                if (r_end >= max_low_pfn)
+                        break;
+                r_start = end;
+        }
+}
+
+static void __init e820_save_acpi_pages(void)
+{
+        int i;
+
+        /* Assume e820 map is sorted */
+        for (i = 0; i < e820.nr_map; i++) {
+                struct e820entry *ei = &e820.map[i];
+                unsigned long start, end;
+
+                start = ei->addr;
+                end = ei->addr + ei->size;
+                if (start >= end)
+                        continue;
+                if (ei->type != E820_ACPI && ei->type != E820_NVS)
+                        continue;
+                /*
+                 * If the region is below max_low_pfn, it will be
+                 * saved/restored by swsusp follow 'RAM' type.
+                 */
+                if (start < (max_low_pfn << PAGE_SHIFT))
+                        start = max_low_pfn << PAGE_SHIFT;
+                /*
+                 * Highmem pages (ACPI NVS/Data) are reserved, but swsusp
+                 * highmem save/restore will not save/restore them. We marked
+                 * them as arch saveable pages here
+                 */
+                if (end > start)
+                        swsusp_add_arch_pages(start, end);
+        }
+}
+
+extern char __start_rodata, __end_rodata;
+/*
+ * BIOS reserved region/hole - no save/restore
+ * ACPI NVS - save/restore
+ * ACPI Data - this is a little tricky, the mem could be used by OS after OS
+ * reads tables from the region, but anyway save/restore the memory hasn't any
+ * side effect and Linux runtime module load/unload might use it.
+ * kernel rodata - no save/restore (kernel rodata isn't changed)
+ */
+static int __init mark_nosave_pages(void)
+{
+        unsigned long pfn_start, pfn_end;
+
+        /* FIXME: provide a version for efi BIOS */
+        if (efi_enabled)
+                return 0;
+        /* BIOS reserved regions & holes */
+        e820_nosave_reserved_pages();
+
+        /* kernel rodata */
+        pfn_start = PFN_UP(virt_to_phys(&__start_rodata));
+        pfn_end = PFN_DOWN(virt_to_phys(&__end_rodata));
+        mark_nosave_page_range(pfn_start, pfn_end-1);
+
+        /* record ACPI Data/NVS as saveable */
+        e820_save_acpi_pages();
+
+        return 0;
+}
+core_initcall(mark_nosave_pages);
+#endif
+
 /*
  * Determine if we were loaded by an EFI loader.  If so, then we have also been
  * passed the efi memmap, systab, etc., so we should use these data structures
diff --git a/arch/i386/kernel/srat.c b/arch/i386/kernel/srat.c
index 52b3ed5d2cb5..989c85255dbe 100644
--- a/arch/i386/kernel/srat.c
+++ b/arch/i386/kernel/srat.c
@@ -39,7 +39,6 @@
 #define NODE_ARRAY_OFFSET(x)    ((x) % 8)       /* 8 bits/char */
 #define BMAP_SET(bmap, bit)     ((bmap)[NODE_ARRAY_INDEX(bit)] |= 1 << NODE_ARRAY_OFFSET(bit))
 #define BMAP_TEST(bmap, bit)    ((bmap)[NODE_ARRAY_INDEX(bit)] & (1 << NODE_ARRAY_OFFSET(bit)))
-#define MAX_PXM_DOMAINS         256     /* 1 byte and no promises about values */
 /* bitmap length; _PXM is at most 255 */
 #define PXM_BITMAP_LEN (MAX_PXM_DOMAINS / 8) 
 static u8 pxm_bitmap[PXM_BITMAP_LEN];   /* bitmap of proximity domains */
@@ -213,19 +212,11 @@ static __init void node_read_chunk(int nid, struct node_memory_chunk_s *memory_c
                 node_end_pfn[nid] = memory_chunk->end_pfn;
 }
 
-static u8 pxm_to_nid_map[MAX_PXM_DOMAINS];/* _PXM to logical node ID map */
-
-int pxm_to_node(int pxm)
-{
-        return pxm_to_nid_map[pxm];
-}
-
 /* Parse the ACPI Static Resource Affinity Table */
 static int __init acpi20_parse_srat(struct acpi_table_srat *sratp)
 {
         u8 *start, *end, *p;
         int i, j, nid;
-        u8 nid_to_pxm_map[MAX_NUMNODES];/* logical node ID to _PXM map */
 
         start = (u8 *)(&(sratp->reserved) + 1); /* skip header */
         p = start;
@@ -235,10 +226,6 @@ static int __init acpi20_parse_srat(struct acpi_table_srat *sratp)
         memset(node_memory_chunk, 0, sizeof(node_memory_chunk));
         memset(zholes_size, 0, sizeof(zholes_size));
 
-        /* -1 in these maps means not available */
-        memset(pxm_to_nid_map, -1, sizeof(pxm_to_nid_map));
-        memset(nid_to_pxm_map, -1, sizeof(nid_to_pxm_map));
-
         num_memory_chunks = 0;
         while (p < end) {
                 switch (*p) {
@@ -278,9 +265,7 @@ static int __init acpi20_parse_srat(struct acpi_table_srat *sratp)
         nodes_clear(node_online_map);
         for (i = 0; i < MAX_PXM_DOMAINS; i++) {
                 if (BMAP_TEST(pxm_bitmap, i)) {
-                        nid = num_online_nodes();
-                        pxm_to_nid_map[i] = nid;
-                        nid_to_pxm_map[nid] = i;
+                        int nid = acpi_map_pxm_to_node(i);
                         node_set_online(nid);
                 }
         }
@@ -288,7 +273,7 @@ static int __init acpi20_parse_srat(struct acpi_table_srat *sratp)
 
         /* set cnode id in memory chunk structure */
         for (i = 0; i < num_memory_chunks; i++)
-                node_memory_chunk[i].nid = pxm_to_nid_map[node_memory_chunk[i].pxm];
+                node_memory_chunk[i].nid = pxm_to_node(node_memory_chunk[i].pxm);
 
         printk("pxm bitmap: ");
         for (i = 0; i < sizeof(pxm_bitmap); i++) {
diff --git a/arch/i386/kernel/syscall_table.S b/arch/i386/kernel/syscall_table.S
index af56987f69b0..dd63d4775398 100644
--- a/arch/i386/kernel/syscall_table.S
+++ b/arch/i386/kernel/syscall_table.S
@@ -316,3 +316,4 @@ ENTRY(sys_call_table)
         .long sys_sync_file_range
         .long sys_tee                   /* 315 */
         .long sys_vmsplice
+        .long sys_move_pages
diff --git a/arch/i386/kernel/traps.c b/arch/i386/kernel/traps.c
index 0e498369f35e..dcc14477af1f 100644
--- a/arch/i386/kernel/traps.c
+++ b/arch/i386/kernel/traps.c
@@ -149,6 +149,12 @@ static inline unsigned long print_context_stack(struct thread_info *tinfo,
         while (valid_stack_ptr(tinfo, (void *)ebp)) {
                 addr = *(unsigned long *)(ebp + 4);
                 printed = print_addr_and_symbol(addr, log_lvl, printed);
+                /*
+                 * break out of recursive entries (such as
+                 * end_of_stack_stop_unwind_function):
+                 */
+                if (ebp == *(unsigned long *)ebp)
+                        break;
                 ebp = *(unsigned long *)ebp;
         }
 #else
@@ -268,8 +274,9 @@ void show_registers(struct pt_regs *regs)
                 regs->esi, regs->edi, regs->ebp, esp);
         printk(KERN_EMERG "ds: %04x   es: %04x   ss: %04x\n",
                 regs->xds & 0xffff, regs->xes & 0xffff, ss);
-        printk(KERN_EMERG "Process %s (pid: %d, threadinfo=%p task=%p)",
-                current->comm, current->pid, current_thread_info(), current);
+        printk(KERN_EMERG "Process %.*s (pid: %d, ti=%p task=%p task.ti=%p)",
+                TASK_COMM_LEN, current->comm, current->pid,
+                current_thread_info(), current, current->thread_info);
         /*
          * When in-kernel, we also print out the stack and code at the
          * time of the fault..
diff --git a/arch/i386/lib/usercopy.c b/arch/i386/lib/usercopy.c
index 4cf981d70f45..6979297ce278 100644
--- a/arch/i386/lib/usercopy.c
+++ b/arch/i386/lib/usercopy.c
@@ -425,15 +425,121 @@ __copy_user_zeroing_intel(void *to, const void __user *from, unsigned long size)
                        : "eax", "edx", "memory");
         return size;
 }
+
+/*
+ * Non Temporal Hint version of __copy_user_zeroing_intel.  It is cache aware.
+ * hyoshiok@miraclelinux.com
+ */
+
+static unsigned long __copy_user_zeroing_intel_nocache(void *to,
+                                const void __user *from, unsigned long size)
+{
+        int d0, d1;
+
+        __asm__ __volatile__(
+               "        .align 2,0x90\n"
+               "0:      movl 32(%4), %%eax\n"
+               "        cmpl $67, %0\n"
+               "        jbe 2f\n"
+               "1:      movl 64(%4), %%eax\n"
+               "        .align 2,0x90\n"
+               "2:      movl 0(%4), %%eax\n"
+               "21:     movl 4(%4), %%edx\n"
+               "        movnti %%eax, 0(%3)\n"
+               "        movnti %%edx, 4(%3)\n"
+               "3:      movl 8(%4), %%eax\n"
+               "31:     movl 12(%4),%%edx\n"
+               "        movnti %%eax, 8(%3)\n"
+               "        movnti %%edx, 12(%3)\n"
+               "4:      movl 16(%4), %%eax\n"
+               "41:     movl 20(%4), %%edx\n"
+               "        movnti %%eax, 16(%3)\n"
+               "        movnti %%edx, 20(%3)\n"
+               "10:     movl 24(%4), %%eax\n"
+               "51:     movl 28(%4), %%edx\n"
+               "        movnti %%eax, 24(%3)\n"
+               "        movnti %%edx, 28(%3)\n"
+               "11:     movl 32(%4), %%eax\n"
+               "61:     movl 36(%4), %%edx\n"
+               "        movnti %%eax, 32(%3)\n"
+               "        movnti %%edx, 36(%3)\n"
+               "12:     movl 40(%4), %%eax\n"
+               "71:     movl 44(%4), %%edx\n"
+               "        movnti %%eax, 40(%3)\n"
+               "        movnti %%edx, 44(%3)\n"
+               "13:     movl 48(%4), %%eax\n"
+               "81:     movl 52(%4), %%edx\n"
+               "        movnti %%eax, 48(%3)\n"
+               "        movnti %%edx, 52(%3)\n"
+               "14:     movl 56(%4), %%eax\n"
+               "91:     movl 60(%4), %%edx\n"
+               "        movnti %%eax, 56(%3)\n"
+               "        movnti %%edx, 60(%3)\n"
+               "        addl $-64, %0\n"
+               "        addl $64, %4\n"
+               "        addl $64, %3\n"
+               "        cmpl $63, %0\n"
+               "        ja  0b\n"
+               "        sfence \n"
+               "5:      movl  %0, %%eax\n"
+               "        shrl  $2, %0\n"
+               "        andl $3, %%eax\n"
+               "        cld\n"
+               "6:      rep; movsl\n"
+               "        movl %%eax,%0\n"
+               "7:      rep; movsb\n"
+               "8:\n"
+               ".section .fixup,\"ax\"\n"
+               "9:      lea 0(%%eax,%0,4),%0\n"
+               "16:     pushl %0\n"
+               "        pushl %%eax\n"
+               "        xorl %%eax,%%eax\n"
+               "        rep; stosb\n"
+               "        popl %%eax\n"
+               "        popl %0\n"
+               "        jmp 8b\n"
+               ".previous\n"
+               ".section __ex_table,\"a\"\n"
+               "        .align 4\n"
+               "        .long 0b,16b\n"
+               "        .long 1b,16b\n"
+               "        .long 2b,16b\n"
+               "        .long 21b,16b\n"
+               "        .long 3b,16b\n"
+               "        .long 31b,16b\n"
+               "        .long 4b,16b\n"
+               "        .long 41b,16b\n"
+               "        .long 10b,16b\n"
+               "        .long 51b,16b\n"
+               "        .long 11b,16b\n"
+               "        .long 61b,16b\n"
+               "        .long 12b,16b\n"
+               "        .long 71b,16b\n"
+               "        .long 13b,16b\n"
+               "        .long 81b,16b\n"
+               "        .long 14b,16b\n"
+               "        .long 91b,16b\n"
+               "        .long 6b,9b\n"
+               "        .long 7b,16b\n"
+               ".previous"
+               : "=&c"(size), "=&D" (d0), "=&S" (d1)
+               :  "1"(to), "2"(from), "0"(size)
+               : "eax", "edx", "memory");
+        return size;
+}
+
 #else
+
 /*
  * Leave these declared but undefined.  They should not be any references to
  * them
  */
-unsigned long
-__copy_user_zeroing_intel(void *to, const void __user *from, unsigned long size);
-unsigned long
-__copy_user_intel(void __user *to, const void *from, unsigned long size);
+unsigned long __copy_user_zeroing_intel(void *to, const void __user *from,
+                                        unsigned long size);
+unsigned long __copy_user_intel(void __user *to, const void *from,
+                                        unsigned long size);
+unsigned long __copy_user_zeroing_intel_nocache(void *to,
+                                const void __user *from, unsigned long size);
 #endif /* CONFIG_X86_INTEL_USERCOPY */
 
 /* Generic arbitrary sized copy.  */
@@ -515,8 +621,8 @@ do {									\
                 : "memory");                                            \
 } while (0)
 
-
-unsigned long __copy_to_user_ll(void __user *to, const void *from, unsigned long n)
+unsigned long __copy_to_user_ll(void __user *to, const void *from,
+                                unsigned long n)
 {
         BUG_ON((long) n < 0);
 #ifndef CONFIG_X86_WP_WORKS_OK
@@ -576,8 +682,8 @@ survive:
 }
 EXPORT_SYMBOL(__copy_to_user_ll);
 
-unsigned long
-__copy_from_user_ll(void *to, const void __user *from, unsigned long n)
+unsigned long __copy_from_user_ll(void *to, const void __user *from,
+                                        unsigned long n)
 {
         BUG_ON((long)n < 0);
         if (movsl_is_ok(to, from, n))
@@ -588,6 +694,21 @@ __copy_from_user_ll(void *to, const void __user *from, unsigned long n)
 }
 EXPORT_SYMBOL(__copy_from_user_ll);
 
+unsigned long __copy_from_user_ll_nocache(void *to, const void __user *from,
+                                        unsigned long n)
+{
+        BUG_ON((long)n < 0);
+#ifdef CONFIG_X86_INTEL_USERCOPY
+        if ( n > 64 && cpu_has_xmm2)
+                n = __copy_user_zeroing_intel_nocache(to, from, n);
+        else
+                __copy_user_zeroing(to, from, n);
+#else
+        __copy_user_zeroing(to, from, n);
+#endif
+        return n;
+}
+
 /**
  * copy_to_user: - Copy a block of data into user space.
  * @to:   Destination address, in user space.
diff --git a/arch/i386/mm/fault.c b/arch/i386/mm/fault.c
index 7f0fcf219a26..bd6fe96cc16d 100644
--- a/arch/i386/mm/fault.c
+++ b/arch/i386/mm/fault.c
@@ -77,12 +77,15 @@ static inline unsigned long get_segment_eip(struct pt_regs *regs,
         unsigned seg = regs->xcs & 0xffff;
         u32 seg_ar, seg_limit, base, *desc;
 
+        /* Unlikely, but must come before segment checks. */
+        if (unlikely(regs->eflags & VM_MASK)) {
+                base = seg << 4;
+                *eip_limit = base + 0xffff;
+                return base + (eip & 0xffff);
+        }
+
         /* The standard kernel/user address space limit. */
         *eip_limit = (seg & 3) ? USER_DS.seg : KERNEL_DS.seg;
-
-        /* Unlikely, but must come before segment checks. */
-        if (unlikely((regs->eflags & VM_MASK) != 0))
-                return eip + (seg << 4);
         
         /* By far the most common cases. */
         if (likely(seg == __USER_CS || seg == __KERNEL_CS))
@@ -380,12 +383,12 @@ fastcall void __kprobes do_page_fault(struct pt_regs *regs,
                 goto bad_area;
         if (error_code & 4) {
                 /*
-                 * accessing the stack below %esp is always a bug.
-                 * The "+ 32" is there due to some instructions (like
-                 * pusha) doing post-decrement on the stack and that
-                 * doesn't show up until later..
+                 * Accessing the stack below %esp is always a bug.
+                 * The large cushion allows instructions like enter
+                 * and pusha to work.  ("enter $65535,$31" pushes
+                 * 32 pointers and then decrements %esp by 65535.)
                  */
-                if (address + 32 < regs->esp)
+                if (address + 65536 + 32 * sizeof(unsigned long) < regs->esp)
                         goto bad_area;
         }
         if (expand_stack(vma, address))
diff --git a/arch/i386/mm/init.c b/arch/i386/mm/init.c
index 3df1371d4520..bf19513f0cea 100644
--- a/arch/i386/mm/init.c
+++ b/arch/i386/mm/init.c
@@ -29,6 +29,7 @@
 #include <linux/efi.h>
 #include <linux/memory_hotplug.h>
 #include <linux/initrd.h>
+#include <linux/cpumask.h>
 
 #include <asm/processor.h>
 #include <asm/system.h>
@@ -384,7 +385,7 @@ static void __init pagetable_init (void)
 #endif
 }
 
-#ifdef CONFIG_SOFTWARE_SUSPEND
+#if defined(CONFIG_SOFTWARE_SUSPEND) || defined(CONFIG_ACPI_SLEEP)
 /*
  * Swap suspend & friends need this for resume because things like the intel-agp
  * driver might have split up a kernel 4MB mapping.
diff --git a/arch/i386/mm/pageattr.c b/arch/i386/mm/pageattr.c
index 92c3d9f0e731..0887b34bc59b 100644
--- a/arch/i386/mm/pageattr.c
+++ b/arch/i386/mm/pageattr.c
@@ -209,19 +209,19 @@ int change_page_attr(struct page *page, int numpages, pgprot_t prot)
 }
 
 void global_flush_tlb(void)
-{ 
-        LIST_HEAD(l);
+{
+        struct list_head l;
         struct page *pg, *next;
 
         BUG_ON(irqs_disabled());
 
         spin_lock_irq(&cpa_lock);
-        list_splice_init(&df_list, &l);
+        list_replace_init(&df_list, &l);
         spin_unlock_irq(&cpa_lock);
         flush_map();
         list_for_each_entry_safe(pg, next, &l, lru)
                 __free_page(pg);
-} 
+}
 
 #ifdef CONFIG_DEBUG_PAGEALLOC
 void kernel_map_pages(struct page *page, int numpages, int enable)
diff --git a/arch/i386/pci/common.c b/arch/i386/pci/common.c
index dbece776c5b2..c624b61e1104 100644
--- a/arch/i386/pci/common.c
+++ b/arch/i386/pci/common.c
@@ -288,6 +288,7 @@ int pcibios_enable_device(struct pci_dev *dev, int mask)
 
 void pcibios_disable_device (struct pci_dev *dev)
 {
+        pcibios_disable_resources(dev);
         if (pcibios_disable_irq)
                 pcibios_disable_irq(dev);
 }
diff --git a/arch/i386/pci/i386.c b/arch/i386/pci/i386.c
index ed2c8c899bd3..7852827a599b 100644
--- a/arch/i386/pci/i386.c
+++ b/arch/i386/pci/i386.c
@@ -242,6 +242,15 @@ int pcibios_enable_resources(struct pci_dev *dev, int mask)
         return 0;
 }
 
+void pcibios_disable_resources(struct pci_dev *dev)
+{
+        u16 cmd;
+
+        pci_read_config_word(dev, PCI_COMMAND, &cmd);
+        cmd &= ~(PCI_COMMAND_IO | PCI_COMMAND_MEMORY);
+        pci_write_config_word(dev, PCI_COMMAND, cmd);
+}
+
 /*
  *  If we set up a device for bus mastering, we need to check the latency
  *  timer as certain crappy BIOSes forget to set it properly.
diff --git a/arch/i386/pci/irq.c b/arch/i386/pci/irq.c
index 06dab00aaadc..8ce69508f3c7 100644
--- a/arch/i386/pci/irq.c
+++ b/arch/i386/pci/irq.c
@@ -198,14 +198,14 @@ static void write_config_nybble(struct pci_dev *router, unsigned offset, unsigne
  */
 static int pirq_ali_get(struct pci_dev *router, struct pci_dev *dev, int pirq)
 {
-        static unsigned char irqmap[16] = { 0, 9, 3, 10, 4, 5, 7, 6, 1, 11, 0, 12, 0, 14, 0, 15 };
+        static const unsigned char irqmap[16] = { 0, 9, 3, 10, 4, 5, 7, 6, 1, 11, 0, 12, 0, 14, 0, 15 };
 
         return irqmap[read_config_nybble(router, 0x48, pirq-1)];
 }
 
 static int pirq_ali_set(struct pci_dev *router, struct pci_dev *dev, int pirq, int irq)
 {
-        static unsigned char irqmap[16] = { 0, 8, 0, 2, 4, 5, 7, 6, 0, 1, 3, 9, 11, 0, 13, 15 };
+        static const unsigned char irqmap[16] = { 0, 8, 0, 2, 4, 5, 7, 6, 0, 1, 3, 9, 11, 0, 13, 15 };
         unsigned int val = irqmap[irq];
                 
         if (val) {
@@ -256,13 +256,13 @@ static int pirq_via_set(struct pci_dev *router, struct pci_dev *dev, int pirq, i
  */
 static int pirq_via586_get(struct pci_dev *router, struct pci_dev *dev, int pirq)
 {
-        static unsigned int pirqmap[4] = { 3, 2, 5, 1 };
+        static const unsigned int pirqmap[4] = { 3, 2, 5, 1 };
         return read_config_nybble(router, 0x55, pirqmap[pirq-1]);
 }
 
 static int pirq_via586_set(struct pci_dev *router, struct pci_dev *dev, int pirq, int irq)
 {
-        static unsigned int pirqmap[4] = { 3, 2, 5, 1 };
+        static const unsigned int pirqmap[4] = { 3, 2, 5, 1 };
         write_config_nybble(router, 0x55, pirqmap[pirq-1], irq);
         return 1;
 }
@@ -274,13 +274,13 @@ static int pirq_via586_set(struct pci_dev *router, struct pci_dev *dev, int pirq
  */
 static int pirq_ite_get(struct pci_dev *router, struct pci_dev *dev, int pirq)
 {
-        static unsigned char pirqmap[4] = { 1, 0, 2, 3 };
+        static const unsigned char pirqmap[4] = { 1, 0, 2, 3 };
         return read_config_nybble(router,0x43, pirqmap[pirq-1]);
 }
 
 static int pirq_ite_set(struct pci_dev *router, struct pci_dev *dev, int pirq, int irq)
 {
-        static unsigned char pirqmap[4] = { 1, 0, 2, 3 };
+        static const unsigned char pirqmap[4] = { 1, 0, 2, 3 };
         write_config_nybble(router, 0x43, pirqmap[pirq-1], irq);
         return 1;
 }
@@ -505,7 +505,7 @@ static int pirq_bios_set(struct pci_dev *router, struct pci_dev *dev, int pirq,
 
 static __init int intel_router_probe(struct irq_router *r, struct pci_dev *router, u16 device)
 {
-        static struct pci_device_id pirq_440gx[] = {
+        static struct pci_device_id __initdata pirq_440gx[] = {
                 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82443GX_0) },
                 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82443GX_2) },
                 { },
@@ -880,6 +880,7 @@ static int pcibios_lookup_irq(struct pci_dev *dev, int assign)
         ((!(pci_probe & PCI_USE_PIRQ_MASK)) || ((1 << irq) & mask)) ) {
                 DBG(" -> got IRQ %d\n", irq);
                 msg = "Found";
+                eisa_set_level_irq(irq);
         } else if (newirq && r->set && (dev->class >> 8) != PCI_CLASS_DISPLAY_VGA) {
                 DBG(" -> assigning IRQ %d", newirq);
                 if (r->set(pirq_router_dev, dev, pirq, newirq)) {
diff --git a/arch/i386/pci/mmconfig.c b/arch/i386/pci/mmconfig.c
index 6b1ea0c9a570..e545b0992c48 100644
--- a/arch/i386/pci/mmconfig.c
+++ b/arch/i386/pci/mmconfig.c
@@ -15,7 +15,9 @@
 #include <asm/e820.h>
 #include "pci.h"
 
-#define MMCONFIG_APER_SIZE (256*1024*1024)
+/* aperture is up to 256MB but BIOS may reserve less */
+#define MMCONFIG_APER_MIN       (2 * 1024*1024)
+#define MMCONFIG_APER_MAX       (256 * 1024*1024)
 
 /* Assume systems with more busses have correct MCFG */
 #define MAX_CHECK_BUS 16
@@ -197,9 +199,10 @@ void __init pci_mmcfg_init(void)
                 return;
 
         if (!e820_all_mapped(pci_mmcfg_config[0].base_address,
-                        pci_mmcfg_config[0].base_address + MMCONFIG_APER_SIZE,
+                        pci_mmcfg_config[0].base_address + MMCONFIG_APER_MIN,
                         E820_RESERVED)) {
-                printk(KERN_ERR "PCI: BIOS Bug: MCFG area is not E820-reserved\n");
+                printk(KERN_ERR "PCI: BIOS Bug: MCFG area at %x is not E820-reserved\n",
+                                pci_mmcfg_config[0].base_address);
                 printk(KERN_ERR "PCI: Not using MMCONFIG.\n");
                 return;
         }
diff --git a/arch/i386/pci/pci.h b/arch/i386/pci/pci.h
index 12035e29108b..12bf3d8dda29 100644
--- a/arch/i386/pci/pci.h
+++ b/arch/i386/pci/pci.h
@@ -35,6 +35,7 @@ extern unsigned int pcibios_max_latency;
 
 void pcibios_resource_survey(void);
 int pcibios_enable_resources(struct pci_dev *, int);
+void pcibios_disable_resources(struct pci_dev *);
 
 /* pci-pc.c */
 
diff --git a/arch/i386/power/cpu.c b/arch/i386/power/cpu.c
index 79b2370c7fac..e6517915fe3e 100644
--- a/arch/i386/power/cpu.c
+++ b/arch/i386/power/cpu.c
@@ -10,6 +10,8 @@
 #include <linux/config.h>
 #include <linux/module.h>
 #include <linux/suspend.h>
+#include <asm/mtrr.h>
+#include <asm/mce.h>
 
 static struct saved_context saved_context;
 
diff --git a/arch/ia64/Kconfig b/arch/ia64/Kconfig
index cd2051f5c9ce..18318749884b 100644
--- a/arch/ia64/Kconfig
+++ b/arch/ia64/Kconfig
@@ -77,6 +77,7 @@ choice
 config IA64_GENERIC
         bool "generic"
         select ACPI
+        select PCI
         select NUMA
         select ACPI_NUMA
         help
@@ -273,7 +274,6 @@ config HOTPLUG_CPU
 config SCHED_SMT
         bool "SMT scheduler support"
         depends on SMP
-        default off
         help
           Improves the CPU scheduler's decision making when dealing with
           Intel IA64 chips with MultiThreading at a cost of slightly increased
diff --git a/arch/ia64/hp/common/sba_iommu.c b/arch/ia64/hp/common/sba_iommu.c
index bdccd0b1eb60..5825ddee58d6 100644
--- a/arch/ia64/hp/common/sba_iommu.c
+++ b/arch/ia64/hp/common/sba_iommu.c
@@ -1958,7 +1958,7 @@ sba_map_ioc_to_node(struct ioc *ioc, acpi_handle handle)
         if (pxm < 0)
                 return;
 
-        node = pxm_to_nid_map[pxm];
+        node = pxm_to_node(pxm);
 
         if (node >= MAX_NUMNODES || !node_online(node))
                 return;
@@ -1999,7 +1999,7 @@ acpi_sba_ioc_add(struct acpi_device *device)
                 if (!iovp_shift)
                         iovp_shift = min(PAGE_SHIFT, 16);
         }
-        ACPI_MEM_FREE(dev_info);
+        kfree(dev_info);
 
         /*
          * default anything not caught above or specified on cmdline to 4k
diff --git a/arch/ia64/kernel/acpi.c b/arch/ia64/kernel/acpi.c
index 58c93a30348c..6ea642beaaee 100644
--- a/arch/ia64/kernel/acpi.c
+++ b/arch/ia64/kernel/acpi.c
@@ -68,8 +68,6 @@ EXPORT_SYMBOL(pm_power_off);
 unsigned char acpi_kbd_controller_present = 1;
 unsigned char acpi_legacy_devices;
 
-static unsigned int __initdata acpi_madt_rev;
-
 unsigned int acpi_cpei_override;
 unsigned int acpi_cpei_phys_cpuid;
 
@@ -243,6 +241,8 @@ acpi_parse_iosapic(acpi_table_entry_header * header, const unsigned long end)
         return iosapic_init(iosapic->address, iosapic->global_irq_base);
 }
 
+static unsigned int __initdata acpi_madt_rev;
+
 static int __init
 acpi_parse_plat_int_src(acpi_table_entry_header * header,
                         const unsigned long end)
@@ -415,9 +415,6 @@ static int __initdata srat_num_cpus;	/* number of cpus */
 static u32 __devinitdata pxm_flag[PXM_FLAG_LEN];
 #define pxm_bit_set(bit)        (set_bit(bit,(void *)pxm_flag))
 #define pxm_bit_test(bit)       (test_bit(bit,(void *)pxm_flag))
-/* maps to convert between proximity domain and logical node ID */
-int __devinitdata pxm_to_nid_map[MAX_PXM_DOMAINS];
-int __initdata nid_to_pxm_map[MAX_NUMNODES];
 static struct acpi_table_slit __initdata *slit_table;
 
 static int get_processor_proximity_domain(struct acpi_table_processor_affinity *pa)
@@ -533,22 +530,17 @@ void __init acpi_numa_arch_fixup(void)
          * MCD - This can probably be dropped now.  No need for pxm ID to node ID
          * mapping with sparse node numbering iff MAX_PXM_DOMAINS <= MAX_NUMNODES.
          */
-        /* calculate total number of nodes in system from PXM bitmap */
-        memset(pxm_to_nid_map, -1, sizeof(pxm_to_nid_map));
-        memset(nid_to_pxm_map, -1, sizeof(nid_to_pxm_map));
         nodes_clear(node_online_map);
         for (i = 0; i < MAX_PXM_DOMAINS; i++) {
                 if (pxm_bit_test(i)) {
-                        int nid = num_online_nodes();
-                        pxm_to_nid_map[i] = nid;
-                        nid_to_pxm_map[nid] = i;
+                        int nid = acpi_map_pxm_to_node(i);
                         node_set_online(nid);
                 }
         }
 
         /* set logical node id in memory chunk structure */
         for (i = 0; i < num_node_memblks; i++)
-                node_memblk[i].nid = pxm_to_nid_map[node_memblk[i].nid];
+                node_memblk[i].nid = pxm_to_node(node_memblk[i].nid);
 
         /* assign memory bank numbers for each chunk on each node */
         for_each_online_node(i) {
@@ -562,7 +554,7 @@ void __init acpi_numa_arch_fixup(void)
 
         /* set logical node id in cpu structure */
         for (i = 0; i < srat_num_cpus; i++)
-                node_cpuid[i].nid = pxm_to_nid_map[node_cpuid[i].nid];
+                node_cpuid[i].nid = pxm_to_node(node_cpuid[i].nid);
 
         printk(KERN_INFO "Number of logical nodes in system = %d\n",
                num_online_nodes());
@@ -575,11 +567,11 @@ void __init acpi_numa_arch_fixup(void)
         for (i = 0; i < slit_table->localities; i++) {
                 if (!pxm_bit_test(i))
                         continue;
-                node_from = pxm_to_nid_map[i];
+                node_from = pxm_to_node(i);
                 for (j = 0; j < slit_table->localities; j++) {
                         if (!pxm_bit_test(j))
                                 continue;
-                        node_to = pxm_to_nid_map[j];
+                        node_to = pxm_to_node(j);
                         node_distance(node_from, node_to) =
                             slit_table->entry[i * slit_table->localities + j];
                 }
@@ -785,9 +777,9 @@ int acpi_map_cpu2node(acpi_handle handle, int cpu, long physid)
 
         /*
          * Assuming that the container driver would have set the proximity
-         * domain and would have initialized pxm_to_nid_map[pxm_id] && pxm_flag
+         * domain and would have initialized pxm_to_node(pxm_id) && pxm_flag
          */
-        node_cpuid[cpu].nid = (pxm_id < 0) ? 0 : pxm_to_nid_map[pxm_id];
+        node_cpuid[cpu].nid = (pxm_id < 0) ? 0 : pxm_to_node(pxm_id);
 
         node_cpuid[cpu].phys_id = physid;
 #endif
@@ -966,7 +958,7 @@ acpi_map_iosapic(acpi_handle handle, u32 depth, void *context, void **ret)
         if (pxm < 0)
                 return AE_OK;
 
-        node = pxm_to_nid_map[pxm];
+        node = pxm_to_node(pxm);
 
         if (node >= MAX_NUMNODES || !node_online(node) ||
             cpus_empty(node_to_cpumask(node)))
diff --git a/arch/ia64/kernel/entry.S b/arch/ia64/kernel/entry.S
index bcb80ca5cf40..32c999f58d12 100644
--- a/arch/ia64/kernel/entry.S
+++ b/arch/ia64/kernel/entry.S
@@ -1584,7 +1584,7 @@ sys_call_table:
         data8 sys_keyctl
         data8 sys_ioprio_set
         data8 sys_ioprio_get                    // 1275
-        data8 sys_ni_syscall
+        data8 sys_move_pages
         data8 sys_inotify_init
         data8 sys_inotify_add_watch
         data8 sys_inotify_rm_watch
diff --git a/arch/ia64/kernel/irq_ia64.c b/arch/ia64/kernel/irq_ia64.c
index 6c4d59fd0364..ef9a2b49307a 100644
--- a/arch/ia64/kernel/irq_ia64.c
+++ b/arch/ia64/kernel/irq_ia64.c
@@ -46,6 +46,10 @@
 
 #define IRQ_DEBUG       0
 
+/* These can be overridden in platform_irq_init */
+int ia64_first_device_vector = IA64_DEF_FIRST_DEVICE_VECTOR;
+int ia64_last_device_vector = IA64_DEF_LAST_DEVICE_VECTOR;
+
 /* default base addr of IPI table */
 void __iomem *ipi_base_addr = ((void __iomem *)
                                (__IA64_UNCACHED_OFFSET | IA64_IPI_DEFAULT_BASE_ADDR));
@@ -60,7 +64,7 @@ __u8 isa_irq_to_vector_map[16] = {
 };
 EXPORT_SYMBOL(isa_irq_to_vector_map);
 
-static unsigned long ia64_vector_mask[BITS_TO_LONGS(IA64_NUM_DEVICE_VECTORS)];
+static unsigned long ia64_vector_mask[BITS_TO_LONGS(IA64_MAX_DEVICE_VECTORS)];
 
 int
 assign_irq_vector (int irq)
@@ -89,6 +93,19 @@ free_irq_vector (int vector)
                 printk(KERN_WARNING "%s: double free!\n", __FUNCTION__);
 }
 
+int
+reserve_irq_vector (int vector)
+{
+        int pos;
+
+        if (vector < IA64_FIRST_DEVICE_VECTOR ||
+            vector > IA64_LAST_DEVICE_VECTOR)
+                return -EINVAL;
+
+        pos = vector - IA64_FIRST_DEVICE_VECTOR;
+        return test_and_set_bit(pos, ia64_vector_mask);
+}
+
 #ifdef CONFIG_SMP
 #       define IS_RESCHEDULE(vec)       (vec == IA64_IPI_RESCHEDULE)
 #else
diff --git a/arch/ia64/kernel/perfmon.c b/arch/ia64/kernel/perfmon.c
index 077f21216b65..6d7bc8ff7b3a 100644
--- a/arch/ia64/kernel/perfmon.c
+++ b/arch/ia64/kernel/perfmon.c
@@ -532,7 +532,6 @@ static ctl_table pfm_sysctl_root[] = {
 static struct ctl_table_header *pfm_sysctl_header;
 
 static int pfm_context_unload(pfm_context_t *ctx, void *arg, int count, struct pt_regs *regs);
-static int pfm_flush(struct file *filp);
 
 #define pfm_get_cpu_var(v)              __ia64_per_cpu_var(v)
 #define pfm_get_cpu_data(a,b)           per_cpu(a, b)
@@ -595,10 +594,11 @@ pfm_get_unmapped_area(struct file *file, unsigned long addr, unsigned long len,
 }
 
 
-static struct super_block *
-pfmfs_get_sb(struct file_system_type *fs_type, int flags, const char *dev_name, void *data)
+static int
+pfmfs_get_sb(struct file_system_type *fs_type, int flags, const char *dev_name, void *data,
+             struct vfsmount *mnt)
 {
-        return get_sb_pseudo(fs_type, "pfm:", NULL, PFMFS_MAGIC);
+        return get_sb_pseudo(fs_type, "pfm:", NULL, PFMFS_MAGIC, mnt);
 }
 
 static struct file_system_type pfm_fs_type = {
@@ -1773,7 +1773,7 @@ pfm_syswide_cleanup_other_cpu(pfm_context_t *ctx)
  * When caller is self-monitoring, the context is unloaded.
  */
 static int
-pfm_flush(struct file *filp)
+pfm_flush(struct file *filp, fl_owner_t id)
 {
         pfm_context_t *ctx;
         struct task_struct *task;
diff --git a/arch/ia64/kernel/uncached.c b/arch/ia64/kernel/uncached.c
index fcd2bad0286f..5f03b9e524dd 100644
--- a/arch/ia64/kernel/uncached.c
+++ b/arch/ia64/kernel/uncached.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2001-2005 Silicon Graphics, Inc.  All rights reserved.
+ * Copyright (C) 2001-2006 Silicon Graphics, Inc.  All rights reserved.
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms of version 2 of the GNU General Public License
@@ -29,15 +29,8 @@
 #include <asm/tlbflush.h>
 #include <asm/sn/arch.h>
 
-#define DEBUG   0
 
-#if DEBUG
-#define dprintk                 printk
-#else
-#define dprintk(x...)           do { } while (0)
-#endif
-
-void __init efi_memmap_walk_uc (efi_freemem_callback_t callback);
+extern void __init efi_memmap_walk_uc(efi_freemem_callback_t, void *);
 
 #define MAX_UNCACHED_GRANULES   5
 static int allocated_granules;
@@ -60,6 +53,7 @@ static void uncached_ipi_visibility(void *data)
 static void uncached_ipi_mc_drain(void *data)
 {
         int status;
+
         status = ia64_pal_mc_drain();
         if (status)
                 printk(KERN_WARNING "ia64_pal_mc_drain() failed with %i on "
@@ -67,30 +61,35 @@ static void uncached_ipi_mc_drain(void *data)
 }
 
 
-static unsigned long
-uncached_get_new_chunk(struct gen_pool *poolp)
+/*
+ * Add a new chunk of uncached memory pages to the specified pool.
+ *
+ * @pool: pool to add new chunk of uncached memory to
+ * @nid: node id of node to allocate memory from, or -1
+ *
+ * This is accomplished by first allocating a granule of cached memory pages
+ * and then converting them to uncached memory pages.
+ */
+static int uncached_add_chunk(struct gen_pool *pool, int nid)
 {
         struct page *page;
-        void *tmp;
         int status, i;
-        unsigned long addr, node;
+        unsigned long c_addr, uc_addr;
 
         if (allocated_granules >= MAX_UNCACHED_GRANULES)
-                return 0;
+                return -1;
+
+        /* attempt to allocate a granule's worth of cached memory pages */
 
-        node = poolp->private;
-        page = alloc_pages_node(node, GFP_KERNEL | __GFP_ZERO,
+        page = alloc_pages_node(nid, GFP_KERNEL | __GFP_ZERO,
                                 IA64_GRANULE_SHIFT-PAGE_SHIFT);
+        if (!page)
+                return -1;
 
-        dprintk(KERN_INFO "get_new_chunk page %p, addr %lx\n",
-                page, (unsigned long)(page-vmem_map) << PAGE_SHIFT);
+        /* convert the memory pages from cached to uncached */
 
-        /*
-         * Do magic if no mem on local node! XXX
-         */
-        if (!page)
-                return 0;
-        tmp = page_address(page);
+        c_addr = (unsigned long)page_address(page);
+        uc_addr = c_addr - PAGE_OFFSET + __IA64_UNCACHED_OFFSET;
 
         /*
          * There's a small race here where it's possible for someone to
@@ -100,76 +99,90 @@ uncached_get_new_chunk(struct gen_pool *poolp)
         for (i = 0; i < (IA64_GRANULE_SIZE / PAGE_SIZE); i++)
                 SetPageUncached(&page[i]);
 
-        flush_tlb_kernel_range(tmp, tmp + IA64_GRANULE_SIZE);
+        flush_tlb_kernel_range(uc_addr, uc_adddr + IA64_GRANULE_SIZE);
 
         status = ia64_pal_prefetch_visibility(PAL_VISIBILITY_PHYSICAL);
-
-        dprintk(KERN_INFO "pal_prefetch_visibility() returns %i on cpu %i\n",
-                status, raw_smp_processor_id());
-
         if (!status) {
                 status = smp_call_function(uncached_ipi_visibility, NULL, 0, 1);
                 if (status)
-                        printk(KERN_WARNING "smp_call_function failed for "
-                               "uncached_ipi_visibility! (%i)\n", status);
+                        goto failed;
         }
 
+        preempt_disable();
+
         if (ia64_platform_is("sn2"))
-                sn_flush_all_caches((unsigned long)tmp, IA64_GRANULE_SIZE);
+                sn_flush_all_caches(uc_addr, IA64_GRANULE_SIZE);
         else
-                flush_icache_range((unsigned long)tmp,
-                                   (unsigned long)tmp+IA64_GRANULE_SIZE);
+                flush_icache_range(uc_addr, uc_addr + IA64_GRANULE_SIZE);
+
+        /* flush the just introduced uncached translation from the TLB */
+        local_flush_tlb_all();
+
+        preempt_enable();
 
         ia64_pal_mc_drain();
         status = smp_call_function(uncached_ipi_mc_drain, NULL, 0, 1);
         if (status)
-                printk(KERN_WARNING "smp_call_function failed for "
-                       "uncached_ipi_mc_drain! (%i)\n", status);
+                goto failed;
 
-        addr = (unsigned long)tmp - PAGE_OFFSET + __IA64_UNCACHED_OFFSET;
+        /*
+         * The chunk of memory pages has been converted to uncached so now we
+         * can add it to the pool.
+         */
+        status = gen_pool_add(pool, uc_addr, IA64_GRANULE_SIZE, nid);
+        if (status)
+                goto failed;
 
         allocated_granules++;
-        return addr;
+        return 0;
+
+        /* failed to convert or add the chunk so give it back to the kernel */
+failed:
+        for (i = 0; i < (IA64_GRANULE_SIZE / PAGE_SIZE); i++)
+                ClearPageUncached(&page[i]);
+
+        free_pages(c_addr, IA64_GRANULE_SHIFT-PAGE_SHIFT);
+        return -1;
 }
 
 
 /*
  * uncached_alloc_page
  *
+ * @starting_nid: node id of node to start with, or -1
+ *
  * Allocate 1 uncached page. Allocates on the requested node. If no
  * uncached pages are available on the requested node, roundrobin starting
- * with higher nodes.
+ * with the next higher node.
  */
-unsigned long
-uncached_alloc_page(int nid)
+unsigned long uncached_alloc_page(int starting_nid)
 {
-        unsigned long maddr;
+        unsigned long uc_addr;
+        struct gen_pool *pool;
+        int nid;
 
-        maddr = gen_pool_alloc(uncached_pool[nid], PAGE_SIZE);
+        if (unlikely(starting_nid >= MAX_NUMNODES))
+                return 0;
 
-        dprintk(KERN_DEBUG "uncached_alloc_page returns %lx on node %i\n",
-                maddr, nid);
+        if (starting_nid < 0)
+                starting_nid = numa_node_id();
+        nid = starting_nid;
 
-        /*
-         * If no memory is availble on our local node, try the
-         * remaining nodes in the system.
-         */
-        if (!maddr) {
-                int i;
-
-                for (i = MAX_NUMNODES - 1; i >= 0; i--) {
-                        if (i == nid || !node_online(i))
-                                continue;
-                        maddr = gen_pool_alloc(uncached_pool[i], PAGE_SIZE);
-                        dprintk(KERN_DEBUG "uncached_alloc_page alternate search "
-                                "returns %lx on node %i\n", maddr, i);
-                        if (maddr) {
-                                break;
-                        }
-                }
-        }
+        do {
+                if (!node_online(nid))
+                        continue;
+                pool = uncached_pool[nid];
+                if (pool == NULL)
+                        continue;
+                do {
+                        uc_addr = gen_pool_alloc(pool, PAGE_SIZE);
+                        if (uc_addr != 0)
+                                return uc_addr;
+                } while (uncached_add_chunk(pool, nid) == 0);
+
+        } while ((nid = (nid + 1) % MAX_NUMNODES) != starting_nid);
 
-        return maddr;
+        return 0;
 }
 EXPORT_SYMBOL(uncached_alloc_page);
 
@@ -177,21 +190,22 @@ EXPORT_SYMBOL(uncached_alloc_page);
 /*
  * uncached_free_page
  *
+ * @uc_addr: uncached address of page to free
+ *
  * Free a single uncached page.
  */
-void
-uncached_free_page(unsigned long maddr)
+void uncached_free_page(unsigned long uc_addr)
 {
-        int node;
-
-        node = paddr_to_nid(maddr - __IA64_UNCACHED_OFFSET);
+        int nid = paddr_to_nid(uc_addr - __IA64_UNCACHED_OFFSET);
+        struct gen_pool *pool = uncached_pool[nid];
 
-        dprintk(KERN_DEBUG "uncached_free_page(%lx) on node %i\n", maddr, node);
+        if (unlikely(pool == NULL))
+                return;
 
-        if ((maddr & (0XFUL << 60)) != __IA64_UNCACHED_OFFSET)
-                panic("uncached_free_page invalid address %lx\n", maddr);
+        if ((uc_addr & (0XFUL << 60)) != __IA64_UNCACHED_OFFSET)
+                panic("uncached_free_page invalid address %lx\n", uc_addr);
 
-        gen_pool_free(uncached_pool[node], maddr, PAGE_SIZE);
+        gen_pool_free(pool, uc_addr, PAGE_SIZE);
 }
 EXPORT_SYMBOL(uncached_free_page);
 
@@ -199,43 +213,39 @@ EXPORT_SYMBOL(uncached_free_page);
 /*
  * uncached_build_memmap,
  *
+ * @uc_start: uncached starting address of a chunk of uncached memory
+ * @uc_end: uncached ending address of a chunk of uncached memory
+ * @arg: ignored, (NULL argument passed in on call to efi_memmap_walk_uc())
+ *
  * Called at boot time to build a map of pages that can be used for
  * memory special operations.
  */
-static int __init
-uncached_build_memmap(unsigned long start, unsigned long end, void *arg)
+static int __init uncached_build_memmap(unsigned long uc_start,
+                                        unsigned long uc_end, void *arg)
 {
-        long length = end - start;
-        int node;
-
-        dprintk(KERN_ERR "uncached_build_memmap(%lx %lx)\n", start, end);
+        int nid = paddr_to_nid(uc_start - __IA64_UNCACHED_OFFSET);
+        struct gen_pool *pool = uncached_pool[nid];
+        size_t size = uc_end - uc_start;
 
         touch_softlockup_watchdog();
-        memset((char *)start, 0, length);
 
-        node = paddr_to_nid(start - __IA64_UNCACHED_OFFSET);
-
-        for (; start < end ; start += PAGE_SIZE) {
-                dprintk(KERN_INFO "sticking %lx into the pool!\n", start);
-                gen_pool_free(uncached_pool[node], start, PAGE_SIZE);
+        if (pool != NULL) {
+                memset((char *)uc_start, 0, size);
+                (void) gen_pool_add(pool, uc_start, size, nid);
         }
-
         return 0;
 }
 
 
-static int __init uncached_init(void) {
-        int i;
+static int __init uncached_init(void)
+{
+        int nid;
 
-        for (i = 0; i < MAX_NUMNODES; i++) {
-                if (!node_online(i))
-                        continue;
-                uncached_pool[i] = gen_pool_create(0, IA64_GRANULE_SHIFT,
-                                                   &uncached_get_new_chunk, i);
+        for_each_online_node(nid) {
+                uncached_pool[nid] = gen_pool_create(PAGE_SHIFT, nid);
         }
 
-        efi_memmap_walk_uc(uncached_build_memmap);
-
+        efi_memmap_walk_uc(uncached_build_memmap, NULL);
         return 0;
 }
 
diff --git a/arch/ia64/mm/init.c b/arch/ia64/mm/init.c
index cafa8776a53d..11f08001f8c2 100644
--- a/arch/ia64/mm/init.c
+++ b/arch/ia64/mm/init.c
@@ -671,9 +671,11 @@ int add_memory(u64 start, u64 size)
 
         return ret;
 }
+EXPORT_SYMBOL_GPL(add_memory);
 
 int remove_memory(u64 start, u64 size)
 {
         return -EINVAL;
 }
+EXPORT_SYMBOL_GPL(remove_memory);
 #endif
diff --git a/arch/ia64/pci/pci.c b/arch/ia64/pci/pci.c
index 30d148f34042..61dd8608da4f 100644
--- a/arch/ia64/pci/pci.c
+++ b/arch/ia64/pci/pci.c
@@ -352,7 +352,7 @@ pci_acpi_scan_root(struct acpi_device *device, int domain, int bus)
         pxm = acpi_get_pxm(controller->acpi_handle);
 #ifdef CONFIG_NUMA
         if (pxm >= 0)
-                controller->node = pxm_to_nid_map[pxm];
+                controller->node = pxm_to_node(pxm);
 #endif
 
         acpi_walk_resources(device->handle, METHOD_NAME__CRS, count_window,
diff --git a/arch/ia64/sn/kernel/io_init.c b/arch/ia64/sn/kernel/io_init.c
index 5101ac462643..dc09a6a28a37 100644
--- a/arch/ia64/sn/kernel/io_init.c
+++ b/arch/ia64/sn/kernel/io_init.c
@@ -58,7 +58,7 @@ static int max_pcibus_number = 255;	/* Default highest pci bus number */
  */
 
 static dma_addr_t
-sn_default_pci_map(struct pci_dev *pdev, unsigned long paddr, size_t size)
+sn_default_pci_map(struct pci_dev *pdev, unsigned long paddr, size_t size, int type)
 {
         return 0;
 }
@@ -457,13 +457,6 @@ void sn_pci_fixup_slot(struct pci_dev *dev)
                 pcidev_info->pdi_sn_irq_info = NULL;
                 kfree(sn_irq_info);
         }
-
-        /*
-         * MSI currently not supported on altix.  Remove this when
-         * the MSI abstraction patches are integrated into the kernel
-         * (sometime after 2.6.16 releases)
-         */
-        dev->no_msi = 1;
 }
 
 /*
diff --git a/arch/ia64/sn/kernel/irq.c b/arch/ia64/sn/kernel/irq.c
index c265e02f5036..dc8e2b696713 100644
--- a/arch/ia64/sn/kernel/irq.c
+++ b/arch/ia64/sn/kernel/irq.c
@@ -26,11 +26,11 @@ static void unregister_intr_pda(struct sn_irq_info *sn_irq_info);
 
 int sn_force_interrupt_flag = 1;
 extern int sn_ioif_inited;
-static struct list_head **sn_irq_lh;
+struct list_head **sn_irq_lh;
 static spinlock_t sn_irq_info_lock = SPIN_LOCK_UNLOCKED; /* non-IRQ lock */
 
-static inline u64 sn_intr_alloc(nasid_t local_nasid, int local_widget,
-                                     u64 sn_irq_info,
+u64 sn_intr_alloc(nasid_t local_nasid, int local_widget,
+                                     struct sn_irq_info *sn_irq_info,
                                      int req_irq, nasid_t req_nasid,
                                      int req_slice)
 {
@@ -40,12 +40,13 @@ static inline u64 sn_intr_alloc(nasid_t local_nasid, int local_widget,
 
         SAL_CALL_NOLOCK(ret_stuff, (u64) SN_SAL_IOIF_INTERRUPT,
                         (u64) SAL_INTR_ALLOC, (u64) local_nasid,
-                        (u64) local_widget, (u64) sn_irq_info, (u64) req_irq,
+                        (u64) local_widget, __pa(sn_irq_info), (u64) req_irq,
                         (u64) req_nasid, (u64) req_slice);
+
         return ret_stuff.status;
 }
 
-static inline void sn_intr_free(nasid_t local_nasid, int local_widget,
+void sn_intr_free(nasid_t local_nasid, int local_widget,
                                 struct sn_irq_info *sn_irq_info)
 {
         struct ia64_sal_retval ret_stuff;
@@ -112,73 +113,91 @@ static void sn_end_irq(unsigned int irq)
 
 static void sn_irq_info_free(struct rcu_head *head);
 
-static void sn_set_affinity_irq(unsigned int irq, cpumask_t mask)
+struct sn_irq_info *sn_retarget_vector(struct sn_irq_info *sn_irq_info,
+                                       nasid_t nasid, int slice)
 {
-        struct sn_irq_info *sn_irq_info, *sn_irq_info_safe;
-        int cpuid, cpuphys;
+        int vector;
+        int cpuphys;
+        int64_t bridge;
+        int local_widget, status;
+        nasid_t local_nasid;
+        struct sn_irq_info *new_irq_info;
+        struct sn_pcibus_provider *pci_provider;
 
-        cpuid = first_cpu(mask);
-        cpuphys = cpu_physical_id(cpuid);
+        new_irq_info = kmalloc(sizeof(struct sn_irq_info), GFP_ATOMIC);
+        if (new_irq_info == NULL)
+                return NULL;
 
-        list_for_each_entry_safe(sn_irq_info, sn_irq_info_safe,
-                                 sn_irq_lh[irq], list) {
-                u64 bridge;
-                int local_widget, status;
-                nasid_t local_nasid;
-                struct sn_irq_info *new_irq_info;
-                struct sn_pcibus_provider *pci_provider;
-
-                new_irq_info = kmalloc(sizeof(struct sn_irq_info), GFP_ATOMIC);
-                if (new_irq_info == NULL)
-                        break;
-                memcpy(new_irq_info, sn_irq_info, sizeof(struct sn_irq_info));
-
-                bridge = (u64) new_irq_info->irq_bridge;
-                if (!bridge) {
-                        kfree(new_irq_info);
-                        break; /* irq is not a device interrupt */
-                }
+        memcpy(new_irq_info, sn_irq_info, sizeof(struct sn_irq_info));
+
+        bridge = (u64) new_irq_info->irq_bridge;
+        if (!bridge) {
+                kfree(new_irq_info);
+                return NULL; /* irq is not a device interrupt */
+        }
 
-                local_nasid = NASID_GET(bridge);
+        local_nasid = NASID_GET(bridge);
 
-                if (local_nasid & 1)
-                        local_widget = TIO_SWIN_WIDGETNUM(bridge);
-                else
-                        local_widget = SWIN_WIDGETNUM(bridge);
+        if (local_nasid & 1)
+                local_widget = TIO_SWIN_WIDGETNUM(bridge);
+        else
+                local_widget = SWIN_WIDGETNUM(bridge);
 
-                /* Free the old PROM new_irq_info structure */
-                sn_intr_free(local_nasid, local_widget, new_irq_info);
-                /* Update kernels new_irq_info with new target info */
-                unregister_intr_pda(new_irq_info);
+        vector = sn_irq_info->irq_irq;
+        /* Free the old PROM new_irq_info structure */
+        sn_intr_free(local_nasid, local_widget, new_irq_info);
+        /* Update kernels new_irq_info with new target info */
+        unregister_intr_pda(new_irq_info);
 
-                /* allocate a new PROM new_irq_info struct */
-                status = sn_intr_alloc(local_nasid, local_widget,
-                                       __pa(new_irq_info), irq,
-                                       cpuid_to_nasid(cpuid),
-                                       cpuid_to_slice(cpuid));
+        /* allocate a new PROM new_irq_info struct */
+        status = sn_intr_alloc(local_nasid, local_widget,
+                               new_irq_info, vector,
+                               nasid, slice);
 
-                /* SAL call failed */
-                if (status) {
-                        kfree(new_irq_info);
-                        break;
-                }
+        /* SAL call failed */
+        if (status) {
+                kfree(new_irq_info);
+                return NULL;
+        }
 
-                new_irq_info->irq_cpuid = cpuid;
-                register_intr_pda(new_irq_info);
+        cpuphys = nasid_slice_to_cpuid(nasid, slice);
+        new_irq_info->irq_cpuid = cpuphys;
+        register_intr_pda(new_irq_info);
 
-                pci_provider = sn_pci_provider[new_irq_info->irq_bridge_type];
-                if (pci_provider && pci_provider->target_interrupt)
-                        (pci_provider->target_interrupt)(new_irq_info);
+        pci_provider = sn_pci_provider[new_irq_info->irq_bridge_type];
 
-                spin_lock(&sn_irq_info_lock);
-                list_replace_rcu(&sn_irq_info->list, &new_irq_info->list);
-                spin_unlock(&sn_irq_info_lock);
-                call_rcu(&sn_irq_info->rcu, sn_irq_info_free);
+        /*
+         * If this represents a line interrupt, target it.  If it's
+         * an msi (irq_int_bit < 0), it's already targeted.
+         */
+        if (new_irq_info->irq_int_bit >= 0 &&
+            pci_provider && pci_provider->target_interrupt)
+                (pci_provider->target_interrupt)(new_irq_info);
+
+        spin_lock(&sn_irq_info_lock);
+        list_replace_rcu(&sn_irq_info->list, &new_irq_info->list);
+        spin_unlock(&sn_irq_info_lock);
+        call_rcu(&sn_irq_info->rcu, sn_irq_info_free);
 
 #ifdef CONFIG_SMP
-                set_irq_affinity_info((irq & 0xff), cpuphys, 0);
+        set_irq_affinity_info((vector & 0xff), cpuphys, 0);
 #endif
-        }
+
+        return new_irq_info;
+}
+
+static void sn_set_affinity_irq(unsigned int irq, cpumask_t mask)
+{
+        struct sn_irq_info *sn_irq_info, *sn_irq_info_safe;
+        nasid_t nasid;
+        int slice;
+
+        nasid = cpuid_to_nasid(first_cpu(mask));
+        slice = cpuid_to_slice(first_cpu(mask));
+
+        list_for_each_entry_safe(sn_irq_info, sn_irq_info_safe,
+                                 sn_irq_lh[irq], list)
+                (void)sn_retarget_vector(sn_irq_info, nasid, slice);
 }
 
 struct hw_interrupt_type irq_type_sn = {
@@ -202,6 +221,9 @@ void sn_irq_init(void)
         int i;
         irq_desc_t *base_desc = irq_desc;
 
+        ia64_first_device_vector = IA64_SN2_FIRST_DEVICE_VECTOR;
+        ia64_last_device_vector = IA64_SN2_LAST_DEVICE_VECTOR;
+
         for (i = 0; i < NR_IRQS; i++) {
                 if (base_desc[i].handler == &no_irq_type) {
                         base_desc[i].handler = &irq_type_sn;
@@ -285,6 +307,7 @@ void sn_irq_fixup(struct pci_dev *pci_dev, struct sn_irq_info *sn_irq_info)
         /* link it into the sn_irq[irq] list */
         spin_lock(&sn_irq_info_lock);
         list_add_rcu(&sn_irq_info->list, sn_irq_lh[sn_irq_info->irq_irq]);
+        reserve_irq_vector(sn_irq_info->irq_irq);
         spin_unlock(&sn_irq_info_lock);
 
         register_intr_pda(sn_irq_info);
@@ -310,8 +333,11 @@ void sn_irq_unfixup(struct pci_dev *pci_dev)
         spin_lock(&sn_irq_info_lock);
         list_del_rcu(&sn_irq_info->list);
         spin_unlock(&sn_irq_info_lock);
+        if (list_empty(sn_irq_lh[sn_irq_info->irq_irq]))
+                free_irq_vector(sn_irq_info->irq_irq);
         call_rcu(&sn_irq_info->rcu, sn_irq_info_free);
         pci_dev_put(pci_dev);
+
 }
 
 static inline void
diff --git a/arch/ia64/sn/kernel/setup.c b/arch/ia64/sn/kernel/setup.c
index 30988dfbddff..93577abae36d 100644
--- a/arch/ia64/sn/kernel/setup.c
+++ b/arch/ia64/sn/kernel/setup.c
@@ -139,7 +139,7 @@ static int __init pxm_to_nasid(int pxm)
         int i;
         int nid;
 
-        nid = pxm_to_nid_map[pxm];
+        nid = pxm_to_node(pxm);
         for (i = 0; i < num_node_memblks; i++) {
                 if (node_memblk[i].nid == nid) {
                         return NASID_GET(node_memblk[i].start_paddr);
@@ -704,7 +704,7 @@ void __init build_cnode_tables(void)
          * cnode == node for all C & M bricks.
          */
         for_each_online_node(node) {
-                nasid = pxm_to_nasid(nid_to_pxm_map[node]);
+                nasid = pxm_to_nasid(node_to_pxm(node));
                 sn_cnodeid_to_nasid[node] = nasid;
                 physical_node_map[nasid] = node;
         }
diff --git a/arch/ia64/sn/kernel/sn2/cache.c b/arch/ia64/sn/kernel/sn2/cache.c
index bc3cfa17cd0f..2862cb33026d 100644
--- a/arch/ia64/sn/kernel/sn2/cache.c
+++ b/arch/ia64/sn/kernel/sn2/cache.c
@@ -3,11 +3,12 @@
  * License.  See the file "COPYING" in the main directory of this archive
  * for more details.
  * 
- * Copyright (C) 2001-2003 Silicon Graphics, Inc. All rights reserved.
+ * Copyright (C) 2001-2003, 2006 Silicon Graphics, Inc. All rights reserved.
  *
  */
 #include <linux/module.h>
 #include <asm/pgalloc.h>
+#include <asm/sn/arch.h>
 
 /**
  * sn_flush_all_caches - flush a range of address from all caches (incl. L4)
@@ -17,18 +18,24 @@
  * Flush a range of addresses from all caches including L4. 
  * All addresses fully or partially contained within 
  * @flush_addr to @flush_addr + @bytes are flushed
- * from the all caches.
+ * from all caches.
  */
 void
 sn_flush_all_caches(long flush_addr, long bytes)
 {
-        flush_icache_range(flush_addr, flush_addr+bytes);
+        unsigned long addr = flush_addr;
+
+        /* SHub1 requires a cached address */
+        if (is_shub1() && (addr & RGN_BITS) == RGN_BASE(RGN_UNCACHED))
+                addr = (addr - RGN_BASE(RGN_UNCACHED)) + RGN_BASE(RGN_KERNEL);
+
+        flush_icache_range(addr, addr + bytes);
         /*
          * The last call may have returned before the caches
          * were actually flushed, so we call it again to make
          * sure.
          */
-        flush_icache_range(flush_addr, flush_addr+bytes);
+        flush_icache_range(addr, addr + bytes);
         mb();
 }
 EXPORT_SYMBOL(sn_flush_all_caches);
diff --git a/arch/ia64/sn/pci/pci_dma.c b/arch/ia64/sn/pci/pci_dma.c
index b4b84c269210..7a291a271511 100644
--- a/arch/ia64/sn/pci/pci_dma.c
+++ b/arch/ia64/sn/pci/pci_dma.c
@@ -11,7 +11,7 @@
 
 #include <linux/module.h>
 #include <asm/dma.h>
-#include <asm/sn/pcibr_provider.h>
+#include <asm/sn/intr.h>
 #include <asm/sn/pcibus_provider_defs.h>
 #include <asm/sn/pcidev.h>
 #include <asm/sn/sn_sal.h>
@@ -113,7 +113,8 @@ void *sn_dma_alloc_coherent(struct device *dev, size_t size,
          * resources.
          */
 
-        *dma_handle = provider->dma_map_consistent(pdev, phys_addr, size);
+        *dma_handle = provider->dma_map_consistent(pdev, phys_addr, size,
+                                                   SN_DMA_ADDR_PHYS);
         if (!*dma_handle) {
                 printk(KERN_ERR "%s: out of ATEs\n", __FUNCTION__);
                 free_pages((unsigned long)cpuaddr, get_order(size));
@@ -176,7 +177,7 @@ dma_addr_t sn_dma_map_single(struct device *dev, void *cpu_addr, size_t size,
         BUG_ON(dev->bus != &pci_bus_type);
 
         phys_addr = __pa(cpu_addr);
-        dma_addr = provider->dma_map(pdev, phys_addr, size);
+        dma_addr = provider->dma_map(pdev, phys_addr, size, SN_DMA_ADDR_PHYS);
         if (!dma_addr) {
                 printk(KERN_ERR "%s: out of ATEs\n", __FUNCTION__);
                 return 0;
@@ -260,7 +261,8 @@ int sn_dma_map_sg(struct device *dev, struct scatterlist *sg, int nhwentries,
         for (i = 0; i < nhwentries; i++, sg++) {
                 phys_addr = SG_ENT_PHYS_ADDRESS(sg);
                 sg->dma_address = provider->dma_map(pdev,
-                                                    phys_addr, sg->length);
+                                                    phys_addr, sg->length,
+                                                    SN_DMA_ADDR_PHYS);
 
                 if (!sg->dma_address) {
                         printk(KERN_ERR "%s: out of ATEs\n", __FUNCTION__);
diff --git a/arch/ia64/sn/pci/pcibr/pcibr_dma.c b/arch/ia64/sn/pci/pcibr/pcibr_dma.c
index 9f86bb6519aa..a86c7b945962 100644
--- a/arch/ia64/sn/pci/pcibr/pcibr_dma.c
+++ b/arch/ia64/sn/pci/pcibr/pcibr_dma.c
@@ -41,7 +41,7 @@ extern int sn_ioif_inited;
 
 static dma_addr_t
 pcibr_dmamap_ate32(struct pcidev_info *info,
-                   u64 paddr, size_t req_size, u64 flags)
+                   u64 paddr, size_t req_size, u64 flags, int dma_flags)
 {
 
         struct pcidev_info *pcidev_info = info->pdi_host_pcidev_info;
@@ -81,9 +81,12 @@ pcibr_dmamap_ate32(struct pcidev_info *info,
         if (IS_PCIX(pcibus_info))
                 ate_flags &= ~(PCI32_ATE_PREF);
 
-        xio_addr =
-            IS_PIC_SOFT(pcibus_info) ? PHYS_TO_DMA(paddr) :
-            PHYS_TO_TIODMA(paddr);
+        if (SN_DMA_ADDRTYPE(dma_flags == SN_DMA_ADDR_PHYS))
+                xio_addr = IS_PIC_SOFT(pcibus_info) ? PHYS_TO_DMA(paddr) :
+                                                      PHYS_TO_TIODMA(paddr);
+        else
+                xio_addr = paddr;
+
         offset = IOPGOFF(xio_addr);
         ate = ate_flags | (xio_addr - offset);
 
@@ -91,6 +94,13 @@ pcibr_dmamap_ate32(struct pcidev_info *info,
         if (IS_PIC_SOFT(pcibus_info)) {
                 ate |= (pcibus_info->pbi_hub_xid << PIC_ATE_TARGETID_SHFT);
         }
+
+        /*
+         * If we're mapping for MSI, set the MSI bit in the ATE
+         */
+        if (dma_flags & SN_DMA_MSI)
+                ate |= PCI32_ATE_MSI;
+
         ate_write(pcibus_info, ate_index, ate_count, ate);
 
         /*
@@ -105,20 +115,27 @@ pcibr_dmamap_ate32(struct pcidev_info *info,
         if (pcibus_info->pbi_devreg[internal_device] & PCIBR_DEV_SWAP_DIR)
                 ATE_SWAP_ON(pci_addr);
 
+
         return pci_addr;
 }
 
 static dma_addr_t
 pcibr_dmatrans_direct64(struct pcidev_info * info, u64 paddr,
-                        u64 dma_attributes)
+                        u64 dma_attributes, int dma_flags)
 {
         struct pcibus_info *pcibus_info = (struct pcibus_info *)
             ((info->pdi_host_pcidev_info)->pdi_pcibus_info);
         u64 pci_addr;
 
         /* Translate to Crosstalk View of Physical Address */
-        pci_addr = (IS_PIC_SOFT(pcibus_info) ? PHYS_TO_DMA(paddr) :
-                    PHYS_TO_TIODMA(paddr)) | dma_attributes;
+        if (SN_DMA_ADDRTYPE(dma_flags) == SN_DMA_ADDR_PHYS)
+                pci_addr = IS_PIC_SOFT(pcibus_info) ?
+                                PHYS_TO_DMA(paddr) :
+                                PHYS_TO_TIODMA(paddr) | dma_attributes;
+        else
+                pci_addr = IS_PIC_SOFT(pcibus_info) ?
+                                paddr :
+                                paddr | dma_attributes;
 
         /* Handle Bus mode */
         if (IS_PCIX(pcibus_info))
@@ -130,7 +147,9 @@ pcibr_dmatrans_direct64(struct pcidev_info * info, u64 paddr,
                     ((u64) pcibus_info->
                      pbi_hub_xid << PIC_PCI64_ATTR_TARG_SHFT);
         } else
-                pci_addr |= TIOCP_PCI64_CMDTYPE_MEM;
+                pci_addr |= (dma_flags & SN_DMA_MSI) ?
+                                TIOCP_PCI64_CMDTYPE_MSI :
+                                TIOCP_PCI64_CMDTYPE_MEM;
 
         /* If PCI mode, func zero uses VCHAN0, every other func uses VCHAN1 */
         if (!IS_PCIX(pcibus_info) && PCI_FUNC(info->pdi_linux_pcidev->devfn))
@@ -141,7 +160,7 @@ pcibr_dmatrans_direct64(struct pcidev_info * info, u64 paddr,
 
 static dma_addr_t
 pcibr_dmatrans_direct32(struct pcidev_info * info,
-                        u64 paddr, size_t req_size, u64 flags)
+                        u64 paddr, size_t req_size, u64 flags, int dma_flags)
 {
         struct pcidev_info *pcidev_info = info->pdi_host_pcidev_info;
         struct pcibus_info *pcibus_info = (struct pcibus_info *)pcidev_info->
@@ -156,8 +175,14 @@ pcibr_dmatrans_direct32(struct pcidev_info * info,
                 return 0;
         }
 
-        xio_addr = IS_PIC_SOFT(pcibus_info) ? PHYS_TO_DMA(paddr) :
-            PHYS_TO_TIODMA(paddr);
+        if (dma_flags & SN_DMA_MSI)
+                return 0;
+
+        if (SN_DMA_ADDRTYPE(dma_flags) == SN_DMA_ADDR_PHYS)
+                xio_addr = IS_PIC_SOFT(pcibus_info) ? PHYS_TO_DMA(paddr) :
+                                                      PHYS_TO_TIODMA(paddr);
+        else
+                xio_addr = paddr;
 
         xio_base = pcibus_info->pbi_dir_xbase;
         offset = xio_addr - xio_base;
@@ -327,7 +352,7 @@ void sn_dma_flush(u64 addr)
  */
 
 dma_addr_t
-pcibr_dma_map(struct pci_dev * hwdev, unsigned long phys_addr, size_t size)
+pcibr_dma_map(struct pci_dev * hwdev, unsigned long phys_addr, size_t size, int dma_flags)
 {
         dma_addr_t dma_handle;
         struct pcidev_info *pcidev_info = SN_PCIDEV_INFO(hwdev);
@@ -344,11 +369,11 @@ pcibr_dma_map(struct pci_dev * hwdev, unsigned long phys_addr, size_t size)
                  */
 
                 dma_handle = pcibr_dmatrans_direct64(pcidev_info, phys_addr,
-                                                     PCI64_ATTR_PREF);
+                                                     PCI64_ATTR_PREF, dma_flags);
         } else {
                 /* Handle 32-63 bit cards via direct mapping */
                 dma_handle = pcibr_dmatrans_direct32(pcidev_info, phys_addr,
-                                                     size, 0);
+                                                     size, 0, dma_flags);
                 if (!dma_handle) {
                         /*
                          * It is a 32 bit card and we cannot do direct mapping,
@@ -356,7 +381,8 @@ pcibr_dma_map(struct pci_dev * hwdev, unsigned long phys_addr, size_t size)
                          */
 
                         dma_handle = pcibr_dmamap_ate32(pcidev_info, phys_addr,
-                                                        size, PCI32_ATE_PREF);
+                                                        size, PCI32_ATE_PREF,
+                                                        dma_flags);
                 }
         }
 
@@ -365,18 +391,18 @@ pcibr_dma_map(struct pci_dev * hwdev, unsigned long phys_addr, size_t size)
 
 dma_addr_t
 pcibr_dma_map_consistent(struct pci_dev * hwdev, unsigned long phys_addr,
-                         size_t size)
+                         size_t size, int dma_flags)
 {
         dma_addr_t dma_handle;
         struct pcidev_info *pcidev_info = SN_PCIDEV_INFO(hwdev);
 
         if (hwdev->dev.coherent_dma_mask == ~0UL) {
                 dma_handle = pcibr_dmatrans_direct64(pcidev_info, phys_addr,
-                                            PCI64_ATTR_BAR);
+                                            PCI64_ATTR_BAR, dma_flags);
         } else {
                 dma_handle = (dma_addr_t) pcibr_dmamap_ate32(pcidev_info,
                                                     phys_addr, size,
-                                                    PCI32_ATE_BAR);
+                                                    PCI32_ATE_BAR, dma_flags);
         }
 
         return dma_handle;
diff --git a/arch/ia64/sn/pci/tioca_provider.c b/arch/ia64/sn/pci/tioca_provider.c
index be0176912968..20de72791b97 100644
--- a/arch/ia64/sn/pci/tioca_provider.c
+++ b/arch/ia64/sn/pci/tioca_provider.c
@@ -515,11 +515,17 @@ tioca_dma_unmap(struct pci_dev *pdev, dma_addr_t bus_addr, int dir)
  * use the GART mapped mode.
  */
 static u64
-tioca_dma_map(struct pci_dev *pdev, u64 paddr, size_t byte_count)
+tioca_dma_map(struct pci_dev *pdev, u64 paddr, size_t byte_count, int dma_flags)
 {
         u64 mapaddr;
 
         /*
+         * Not supported for now ...
+         */
+        if (dma_flags & SN_DMA_MSI)
+                return 0;
+
+        /*
          * If card is 64 or 48 bit addresable, use a direct mapping.  32
          * bit direct is so restrictive w.r.t. where the memory resides that
          * we don't use it even though CA has some support.
diff --git a/arch/ia64/sn/pci/tioce_provider.c b/arch/ia64/sn/pci/tioce_provider.c
index 85f3b3d4c606..2d7948567ebc 100644
--- a/arch/ia64/sn/pci/tioce_provider.c
+++ b/arch/ia64/sn/pci/tioce_provider.c
@@ -170,7 +170,8 @@ tioce_mmr_war_post(struct tioce_kernel *kern, void *mmr_addr)
         (ATE_PAGE((start)+(len)-1, pagesize) - ATE_PAGE(start, pagesize) + 1)
 
 #define ATE_VALID(ate)  ((ate) & (1UL << 63))
-#define ATE_MAKE(addr, ps) (((addr) & ~ATE_PAGEMASK(ps)) | (1UL << 63))
+#define ATE_MAKE(addr, ps, msi) \
+        (((addr) & ~ATE_PAGEMASK(ps)) | (1UL << 63) | ((msi)?(1UL << 62):0))
 
 /*
  * Flavors of ate-based mapping supported by tioce_alloc_map()
@@ -196,15 +197,17 @@ tioce_mmr_war_post(struct tioce_kernel *kern, void *mmr_addr)
  *
  * 63    - must be 1 to indicate d64 mode to CE hardware
  * 62    - barrier bit ... controlled with tioce_dma_barrier()
- * 61    - 0 since this is not an MSI transaction
+ * 61    - msi bit ... specified through dma_flags
  * 60:54 - reserved, MBZ
  */
 static u64
-tioce_dma_d64(unsigned long ct_addr)
+tioce_dma_d64(unsigned long ct_addr, int dma_flags)
 {
         u64 bus_addr;
 
         bus_addr = ct_addr | (1UL << 63);
+        if (dma_flags & SN_DMA_MSI)
+                bus_addr |= (1UL << 61);
 
         return bus_addr;
 }
@@ -261,7 +264,7 @@ pcidev_to_tioce(struct pci_dev *pdev, struct tioce **base,
  */
 static u64
 tioce_alloc_map(struct tioce_kernel *ce_kern, int type, int port,
-                u64 ct_addr, int len)
+                u64 ct_addr, int len, int dma_flags)
 {
         int i;
         int j;
@@ -270,6 +273,7 @@ tioce_alloc_map(struct tioce_kernel *ce_kern, int type, int port,
         int entries;
         int nates;
         u64 pagesize;
+        int msi_capable, msi_wanted;
         u64 *ate_shadow;
         u64 *ate_reg;
         u64 addr;
@@ -291,6 +295,7 @@ tioce_alloc_map(struct tioce_kernel *ce_kern, int type, int port,
                 ate_reg = ce_mmr->ce_ure_ate3240;
                 pagesize = ce_kern->ce_ate3240_pagesize;
                 bus_base = TIOCE_M32_MIN;
+                msi_capable = 1;
                 break;
         case TIOCE_ATE_M40:
                 first = 0;
@@ -299,6 +304,7 @@ tioce_alloc_map(struct tioce_kernel *ce_kern, int type, int port,
                 ate_reg = ce_mmr->ce_ure_ate40;
                 pagesize = MB(64);
                 bus_base = TIOCE_M40_MIN;
+                msi_capable = 0;
                 break;
         case TIOCE_ATE_M40S:
                 /*
@@ -311,11 +317,16 @@ tioce_alloc_map(struct tioce_kernel *ce_kern, int type, int port,
                 ate_reg = ce_mmr->ce_ure_ate3240;
                 pagesize = GB(16);
                 bus_base = TIOCE_M40S_MIN;
+                msi_capable = 0;
                 break;
         default:
                 return 0;
         }
 
+        msi_wanted = dma_flags & SN_DMA_MSI;
+        if (msi_wanted && !msi_capable)
+                return 0;
+
         nates = ATE_NPAGES(ct_addr, len, pagesize);
         if (nates > entries)
                 return 0;
@@ -344,7 +355,7 @@ tioce_alloc_map(struct tioce_kernel *ce_kern, int type, int port,
         for (j = 0; j < nates; j++) {
                 u64 ate;
 
-                ate = ATE_MAKE(addr, pagesize);
+                ate = ATE_MAKE(addr, pagesize, msi_wanted);
                 ate_shadow[i + j] = ate;
                 tioce_mmr_storei(ce_kern, &ate_reg[i + j], ate);
                 addr += pagesize;
@@ -371,7 +382,7 @@ 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 u64
-tioce_dma_d32(struct pci_dev *pdev, u64 ct_addr)
+tioce_dma_d32(struct pci_dev *pdev, u64 ct_addr, int dma_flags)
 {
         int dma_ok;
         int port;
@@ -381,6 +392,9 @@ tioce_dma_d32(struct pci_dev *pdev, u64 ct_addr)
         u64 ct_lower;
         dma_addr_t bus_addr;
 
+        if (dma_flags & SN_DMA_MSI)
+                return 0;
+
         ct_upper = ct_addr & ~0x3fffffffUL;
         ct_lower = ct_addr & 0x3fffffffUL;
 
@@ -507,7 +521,7 @@ tioce_dma_unmap(struct pci_dev *pdev, dma_addr_t bus_addr, int dir)
  */
 static u64
 tioce_do_dma_map(struct pci_dev *pdev, u64 paddr, size_t byte_count,
-                 int barrier)
+                 int barrier, int dma_flags)
 {
         unsigned long flags;
         u64 ct_addr;
@@ -523,15 +537,18 @@ tioce_do_dma_map(struct pci_dev *pdev, u64 paddr, size_t byte_count,
         if (dma_mask < 0x7fffffffUL)
                 return 0;
 
-        ct_addr = PHYS_TO_TIODMA(paddr);
+        if (SN_DMA_ADDRTYPE(dma_flags) == SN_DMA_ADDR_PHYS)
+                ct_addr = PHYS_TO_TIODMA(paddr);
+        else
+                ct_addr = paddr;
 
         /*
          * If the device can generate 64 bit addresses, create a D64 map.
-         * Since this should never fail, bypass the rest of the checks.
          */
         if (dma_mask == ~0UL) {
-                mapaddr = tioce_dma_d64(ct_addr);
-                goto dma_map_done;
+                mapaddr = tioce_dma_d64(ct_addr, dma_flags);
+                if (mapaddr)
+                        goto dma_map_done;
         }
 
         pcidev_to_tioce(pdev, NULL, &ce_kern, &port);
@@ -574,18 +591,22 @@ tioce_do_dma_map(struct pci_dev *pdev, u64 paddr, size_t byte_count,
 
                 if (byte_count > MB(64)) {
                         mapaddr = tioce_alloc_map(ce_kern, TIOCE_ATE_M40S,
-                                                  port, ct_addr, byte_count);
+                                                  port, ct_addr, byte_count,
+                                                  dma_flags);
                         if (!mapaddr)
                                 mapaddr =
                                     tioce_alloc_map(ce_kern, TIOCE_ATE_M40, -1,
-                                                    ct_addr, byte_count);
+                                                    ct_addr, byte_count,
+                                                    dma_flags);
                 } else {
                         mapaddr = tioce_alloc_map(ce_kern, TIOCE_ATE_M40, -1,
-                                                  ct_addr, byte_count);
+                                                  ct_addr, byte_count,
+                                                  dma_flags);
                         if (!mapaddr)
                                 mapaddr =
                                     tioce_alloc_map(ce_kern, TIOCE_ATE_M40S,
-                                                    port, ct_addr, byte_count);
+                                                    port, ct_addr, byte_count,
+                                                    dma_flags);
                 }
         }
 
@@ -593,7 +614,7 @@ tioce_do_dma_map(struct pci_dev *pdev, u64 paddr, size_t byte_count,
          * 32-bit direct is the next mode to try
          */
         if (!mapaddr && dma_mask >= 0xffffffffUL)
-                mapaddr = tioce_dma_d32(pdev, ct_addr);
+                mapaddr = tioce_dma_d32(pdev, ct_addr, dma_flags);
 
         /*
          * Last resort, try 32-bit ATE-based map.
@@ -601,7 +622,7 @@ tioce_do_dma_map(struct pci_dev *pdev, u64 paddr, size_t byte_count,
         if (!mapaddr)
                 mapaddr =
                     tioce_alloc_map(ce_kern, TIOCE_ATE_M32, -1, ct_addr,
-                                    byte_count);
+                                    byte_count, dma_flags);
 
         spin_unlock_irqrestore(&ce_kern->ce_lock, flags);
 
@@ -622,9 +643,9 @@ dma_map_done:
  * in the address.
  */
 static u64
-tioce_dma(struct pci_dev *pdev, u64 paddr, size_t byte_count)
+tioce_dma(struct pci_dev *pdev, u64 paddr, size_t byte_count, int dma_flags)
 {
-        return tioce_do_dma_map(pdev, paddr, byte_count, 0);
+        return tioce_do_dma_map(pdev, paddr, byte_count, 0, dma_flags);
 }
 
 /**
@@ -636,9 +657,9 @@ tioce_dma(struct pci_dev *pdev, u64 paddr, size_t byte_count)
  * Simply call tioce_do_dma_map() to create a map with the barrier bit set
  * in the address.
  */ static u64
-tioce_dma_consistent(struct pci_dev *pdev, u64 paddr, size_t byte_count)
+tioce_dma_consistent(struct pci_dev *pdev, u64 paddr, size_t byte_count, int dma_flags)
 {
-        return tioce_do_dma_map(pdev, paddr, byte_count, 1);
+        return tioce_do_dma_map(pdev, paddr, byte_count, 1, dma_flags);
 }
 
 /**
@@ -696,7 +717,7 @@ tioce_reserve_m32(struct tioce_kernel *ce_kern, u64 base, u64 limit)
         while (ate_index <= last_ate) {
                 u64 ate;
 
-                ate = ATE_MAKE(0xdeadbeef, ps);
+                ate = ATE_MAKE(0xdeadbeef, ps, 0);
                 ce_kern->ce_ate3240_shadow[ate_index] = ate;
                 tioce_mmr_storei(ce_kern, &ce_mmr->ce_ure_ate3240[ate_index],
                                  ate);
diff --git a/arch/m68k/kernel/entry.S b/arch/m68k/kernel/entry.S
index 320fde05dc63..522079f8c2ba 100644
--- a/arch/m68k/kernel/entry.S
+++ b/arch/m68k/kernel/entry.S
@@ -226,7 +226,7 @@ ENTRY(nmi_handler)
 inthandler:
         SAVE_ALL_INT
         GET_CURRENT(%d0)
-        addqb   #1,%curptr@(TASK_INFO+TINFO_PREEMPT+2)
+        addqb   #1,%curptr@(TASK_INFO+TINFO_PREEMPT+1)
                                         |  put exception # in d0
         bfextu %sp@(PT_VECTOR){#4,#10},%d0
 
@@ -245,7 +245,7 @@ inthandler:
 3:      addql   #8,%sp                  |  pop parameters off stack
 
 ret_from_interrupt:
-        subqb   #1,%curptr@(TASK_INFO+TINFO_PREEMPT+2)
+        subqb   #1,%curptr@(TASK_INFO+TINFO_PREEMPT+1)
         jeq     1f
 2:
         RESTORE_ALL
diff --git a/arch/m68k/kernel/ints.c b/arch/m68k/kernel/ints.c
index 514d323ad536..4b85514792e7 100644
--- a/arch/m68k/kernel/ints.c
+++ b/arch/m68k/kernel/ints.c
@@ -95,6 +95,12 @@ void __init init_IRQ(void)
 {
         int i;
 
+        /* assembly irq entry code relies on this... */
+        if (HARDIRQ_MASK != 0x00ff0000) {
+                extern void hardirq_mask_is_broken(void);
+                hardirq_mask_is_broken();
+        }
+
         for (i = 0; i < SYS_IRQS; i++) {
                 if (mach_default_handler)
                         irq_list[i].handler = (*mach_default_handler)[i];
diff --git a/arch/m68k/kernel/signal.c b/arch/m68k/kernel/signal.c
index 866917bfa028..f9af893cd289 100644
--- a/arch/m68k/kernel/signal.c
+++ b/arch/m68k/kernel/signal.c
@@ -763,7 +763,7 @@ get_sigframe(struct k_sigaction *ka, struct pt_regs *regs, size_t frame_size)
 
         /* This is the X/Open sanctioned signal stack switching.  */
         if (ka->sa.sa_flags & SA_ONSTACK) {
-                if (!on_sig_stack(usp))
+                if (!sas_ss_flags(usp))
                         usp = current->sas_ss_sp + current->sas_ss_size;
         }
         return (void __user *)((usp - frame_size) & -8UL);
diff --git a/arch/m68k/kernel/traps.c b/arch/m68k/kernel/traps.c
index cdf58fbb3e73..837a88709902 100644
--- a/arch/m68k/kernel/traps.c
+++ b/arch/m68k/kernel/traps.c
@@ -114,7 +114,7 @@ void __init base_trap_init(void)
         if(MACH_IS_SUN3X) {
                 extern e_vector *sun3x_prom_vbr;
 
-                __asm__ volatile ("movec %%vbr, %0" : "=r" ((void*)sun3x_prom_vbr));
+                __asm__ volatile ("movec %%vbr, %0" : "=r" (sun3x_prom_vbr));
         }
 
         /* setup the exception vector table */
@@ -992,6 +992,7 @@ void show_registers(struct pt_regs *regs)
 
 void show_stack(struct task_struct *task, unsigned long *stack)
 {
+        unsigned long *p;
         unsigned long *endstack;
         int i;
 
@@ -1004,12 +1005,13 @@ void show_stack(struct task_struct *task, unsigned long *stack)
         endstack = (unsigned long *)(((unsigned long)stack + THREAD_SIZE - 1) & -THREAD_SIZE);
 
         printk("Stack from %08lx:", (unsigned long)stack);
+        p = stack;
         for (i = 0; i < kstack_depth_to_print; i++) {
-                if (stack + 1 > endstack)
+                if (p + 1 > endstack)
                         break;
                 if (i % 8 == 0)
                         printk("\n       ");
-                printk(" %08lx", *stack++);
+                printk(" %08lx", *p++);
         }
         printk("\n");
         show_trace(stack);
diff --git a/arch/m68k/lib/Makefile b/arch/m68k/lib/Makefile
index ebe51a513817..6bbf19f96007 100644
--- a/arch/m68k/lib/Makefile
+++ b/arch/m68k/lib/Makefile
@@ -4,5 +4,5 @@
 
 EXTRA_AFLAGS := -traditional
 
-lib-y           := ashldi3.o ashrdi3.o lshrdi3.o muldi3.o \
-                        checksum.o string.o semaphore.o
+lib-y   := ashldi3.o ashrdi3.o lshrdi3.o muldi3.o \
+           checksum.o string.o semaphore.o uaccess.o
diff --git a/arch/m68k/lib/uaccess.c b/arch/m68k/lib/uaccess.c
new file mode 100644
index 000000000000..1bc188c0d983
--- /dev/null
+++ b/arch/m68k/lib/uaccess.c
@@ -0,0 +1,222 @@
+/*
+ * 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/uaccess.h>
+
+unsigned long __generic_copy_from_user(void *to, const void __user *from,
+                                       unsigned long n)
+{
+        unsigned long tmp, res;
+
+        asm volatile ("\n"
+                "       tst.l   %0\n"
+                "       jeq     2f\n"
+                "1:     moves.l (%1)+,%3\n"
+                "       move.l  %3,(%2)+\n"
+                "       subq.l  #1,%0\n"
+                "       jne     1b\n"
+                "2:     btst    #1,%5\n"
+                "       jeq     4f\n"
+                "3:     moves.w (%1)+,%3\n"
+                "       move.w  %3,(%2)+\n"
+                "4:     btst    #0,%5\n"
+                "       jeq     6f\n"
+                "5:     moves.b (%1)+,%3\n"
+                "       move.b  %3,(%2)+\n"
+                "6:\n"
+                "       .section .fixup,\"ax\"\n"
+                "       .even\n"
+                "10:    move.l  %0,%3\n"
+                "7:     clr.l   (%2)+\n"
+                "       subq.l  #1,%3\n"
+                "       jne     7b\n"
+                "       lsl.l   #2,%0\n"
+                "       btst    #1,%5\n"
+                "       jeq     8f\n"
+                "30:    clr.w   (%2)+\n"
+                "       addq.l  #2,%0\n"
+                "8:     btst    #0,%5\n"
+                "       jeq     6b\n"
+                "50:    clr.b   (%2)+\n"
+                "       addq.l  #1,%0\n"
+                "       jra     6b\n"
+                "       .previous\n"
+                "\n"
+                "       .section __ex_table,\"a\"\n"
+                "       .align  4\n"
+                "       .long   1b,10b\n"
+                "       .long   3b,30b\n"
+                "       .long   5b,50b\n"
+                "       .previous"
+                : "=d" (res), "+a" (from), "+a" (to), "=&r" (tmp)
+                : "0" (n / 4), "d" (n & 3));
+
+        return res;
+}
+EXPORT_SYMBOL(__generic_copy_from_user);
+
+unsigned long __generic_copy_to_user(void __user *to, const void *from,
+                                     unsigned long n)
+{
+        unsigned long tmp, res;
+
+        asm volatile ("\n"
+                "       tst.l   %0\n"
+                "       jeq     4f\n"
+                "1:     move.l  (%1)+,%3\n"
+                "2:     moves.l %3,(%2)+\n"
+                "3:     subq.l  #1,%0\n"
+                "       jne     1b\n"
+                "4:     btst    #1,%5\n"
+                "       jeq     6f\n"
+                "       move.w  (%1)+,%3\n"
+                "5:     moves.w %3,(%2)+\n"
+                "6:     btst    #0,%5\n"
+                "       jeq     8f\n"
+                "       move.b  (%1)+,%3\n"
+                "7:     moves.b  %3,(%2)+\n"
+                "8:\n"
+                "       .section .fixup,\"ax\"\n"
+                "       .even\n"
+                "20:    lsl.l   #2,%0\n"
+                "50:    add.l   %5,%0\n"
+                "       jra     7b\n"
+                "       .previous\n"
+                "\n"
+                "       .section __ex_table,\"a\"\n"
+                "       .align  4\n"
+                "       .long   2b,20b\n"
+                "       .long   3b,20b\n"
+                "       .long   5b,50b\n"
+                "       .long   6b,50b\n"
+                "       .long   7b,50b\n"
+                "       .long   8b,50b\n"
+                "       .previous"
+                : "=d" (res), "+a" (from), "+a" (to), "=&r" (tmp)
+                : "0" (n / 4), "d" (n & 3));
+
+        return res;
+}
+EXPORT_SYMBOL(__generic_copy_to_user);
+
+/*
+ * Copy a null terminated string from userspace.
+ */
+long strncpy_from_user(char *dst, const char __user *src, long count)
+{
+        long res;
+        char c;
+
+        if (count <= 0)
+                return count;
+
+        asm volatile ("\n"
+                "1:     moves.b (%2)+,%4\n"
+                "       move.b  %4,(%1)+\n"
+                "       jeq     2f\n"
+                "       subq.l  #1,%3\n"
+                "       jne     1b\n"
+                "2:     sub.l   %3,%0\n"
+                "3:\n"
+                "       .section .fixup,\"ax\"\n"
+                "       .even\n"
+                "10:    move.l  %5,%0\n"
+                "       jra     3b\n"
+                "       .previous\n"
+                "\n"
+                "       .section __ex_table,\"a\"\n"
+                "       .align  4\n"
+                "       .long   1b,10b\n"
+                "       .previous"
+                : "=d" (res), "+a" (dst), "+a" (src), "+r" (count), "=&d" (c)
+                : "i" (-EFAULT), "0" (count));
+
+        return res;
+}
+EXPORT_SYMBOL(strncpy_from_user);
+
+/*
+ * Return the size of a string (including the ending 0)
+ *
+ * Return 0 on exception, a value greater than N if too long
+ */
+long strnlen_user(const char __user *src, long n)
+{
+        char c;
+        long res;
+
+        asm volatile ("\n"
+                "1:     subq.l  #1,%1\n"
+                "       jmi     3f\n"
+                "2:     moves.b (%0)+,%2\n"
+                "       tst.b   %2\n"
+                "       jne     1b\n"
+                "       jra     4f\n"
+                "\n"
+                "3:     addq.l  #1,%0\n"
+                "4:     sub.l   %4,%0\n"
+                "5:\n"
+                "       .section .fixup,\"ax\"\n"
+                "       .even\n"
+                "20:    sub.l   %0,%0\n"
+                "       jra     5b\n"
+                "       .previous\n"
+                "\n"
+                "       .section __ex_table,\"a\"\n"
+                "       .align  4\n"
+                "       .long   2b,20b\n"
+                "       .previous\n"
+                : "=&a" (res), "+d" (n), "=&d" (c)
+                : "0" (src), "r" (src));
+
+        return res;
+}
+EXPORT_SYMBOL(strnlen_user);
+
+/*
+ * Zero Userspace
+ */
+
+unsigned long clear_user(void __user *to, unsigned long n)
+{
+        unsigned long res;
+
+        asm volatile ("\n"
+                "       tst.l   %0\n"
+                "       jeq     3f\n"
+                "1:     moves.l %2,(%1)+\n"
+                "2:     subq.l  #1,%0\n"
+                "       jne     1b\n"
+                "3:     btst    #1,%4\n"
+                "       jeq     5f\n"
+                "4:     moves.w %2,(%1)+\n"
+                "5:     btst    #0,%4\n"
+                "       jeq     7f\n"
+                "6:     moves.b %2,(%1)\n"
+                "7:\n"
+                "       .section .fixup,\"ax\"\n"
+                "       .even\n"
+                "10:    lsl.l   #2,%0\n"
+                "40:    add.l   %4,%0\n"
+                "       jra     7b\n"
+                "       .previous\n"
+                "\n"
+                "       .section __ex_table,\"a\"\n"
+                "       .align  4\n"
+                "       .long   1b,10b\n"
+                "       .long   2b,10b\n"
+                "       .long   4b,40b\n"
+                "       .long   5b,40b\n"
+                "       .long   6b,40b\n"
+                "       .long   7b,40b\n"
+                "       .previous"
+                : "=d" (res), "+a" (to)
+                : "r" (0), "0" (n / 4), "d" (n & 3));
+
+    return res;
+}
+EXPORT_SYMBOL(clear_user);
diff --git a/arch/m68k/mac/config.c b/arch/m68k/mac/config.c
index 14f8d3f4e195..19dce75711b1 100644
--- a/arch/m68k/mac/config.c
+++ b/arch/m68k/mac/config.c
@@ -89,24 +89,11 @@ extern void mac_debugging_long(int, long);
 
 static void mac_get_model(char *str);
 
-void mac_bang(int irq, void *vector, struct pt_regs *p)
-{
-        printk(KERN_INFO "Resetting ...\n");
-        mac_reset();
-}
-
 static void mac_sched_init(irqreturn_t (*vector)(int, void *, struct pt_regs *))
 {
         via_init_clock(vector);
 }
 
-#if 0
-void mac_waitbut (void)
-{
-        ;
-}
-#endif
-
 extern irqreturn_t mac_default_handler(int, void *, struct pt_regs *);
 
 irqreturn_t (*mac_handlers[8])(int, void *, struct pt_regs *)=
diff --git a/arch/m68k/mac/macints.c b/arch/m68k/mac/macints.c
index 1809601ad903..7a1600bd195d 100644
--- a/arch/m68k/mac/macints.c
+++ b/arch/m68k/mac/macints.c
@@ -216,7 +216,6 @@ static void scc_irq_disable(int);
  * console_loglevel determines NMI handler function
  */
 
-extern irqreturn_t mac_bang(int, void *, struct pt_regs *);
 irqreturn_t mac_nmi_handler(int, void *, struct pt_regs *);
 irqreturn_t mac_debug_handler(int, void *, struct pt_regs *);
 
diff --git a/arch/m68k/mac/via.c b/arch/m68k/mac/via.c
index cd528bf7b43f..a6e3814c8666 100644
--- a/arch/m68k/mac/via.c
+++ b/arch/m68k/mac/via.c
@@ -25,7 +25,6 @@
 #include <linux/init.h>
 #include <linux/ide.h>
 
-#include <asm/traps.h>
 #include <asm/bootinfo.h>
 #include <asm/macintosh.h>
 #include <asm/macints.h>
@@ -71,7 +70,6 @@ void via_irq_enable(int irq);
 void via_irq_disable(int irq);
 void via_irq_clear(int irq);
 
-extern irqreturn_t mac_bang(int, void *, struct pt_regs *);
 extern irqreturn_t mac_scc_dispatch(int, void *, struct pt_regs *);
 extern int oss_present;
 
@@ -212,11 +210,6 @@ void __init via_init(void)
                         break;
         }
 #else
-        /* The alernate IRQ mapping seems to just not work. Anyone with a   */
-        /* supported machine is welcome to take a stab at fixing it. It     */
-        /* _should_ work on the following Quadras: 610,650,700,800,900,950  */
-        /*                                               - 1999-06-12 (jmt) */
-
         via_alt_mapping = 0;
 #endif
 
@@ -270,12 +263,6 @@ void __init via_register_interrupts(void)
                 cpu_request_irq(IRQ_AUTO_1, via1_irq,
                                 IRQ_FLG_LOCK|IRQ_FLG_FAST, "via1",
                                 (void *) via1);
-#if 0 /* interferes with serial on some machines */
-                if (!psc_present) {
-                        cpu_request_irq(IRQ_AUTO_6, mac_bang, IRQ_FLG_LOCK,
-                                        "Off Switch", mac_bang);
-                }
-#endif
         }
         cpu_request_irq(IRQ_AUTO_2, via2_irq, IRQ_FLG_LOCK|IRQ_FLG_FAST,
                         "via2", (void *) via2);
@@ -471,8 +458,8 @@ irqreturn_t via2_irq(int irq, void *dev_id, struct pt_regs *regs)
         for (i = 0, irq_bit = 1 ; i < 7 ; i++, irq_bit <<= 1)
                 if (events & irq_bit) {
                         via2[gIER] = irq_bit;
-                        mac_do_irq_list(VIA2_SOURCE_BASE + i, regs);
                         via2[gIFR] = irq_bit | rbv_clear;
+                        mac_do_irq_list(VIA2_SOURCE_BASE + i, regs);
                         via2[gIER] = irq_bit | 0x80;
                 }
         return IRQ_HANDLED;
@@ -529,6 +516,7 @@ void via_irq_enable(int irq) {
                 }
                 via2[gIER] = irq_bit | 0x80;
         } else if (irq_src == 7) {
+                nubus_active |= irq_bit;
                 if (rbv_present) {
                         /* enable the slot interrupt. SIER works like IER. */
                         via2[rSIER] = IER_SET_BIT(irq_idx);
@@ -550,7 +538,6 @@ void via_irq_enable(int irq) {
                                 }
                         }
                 }
-                nubus_active |= irq_bit;
         }
 }
 
diff --git a/arch/m68k/mm/motorola.c b/arch/m68k/mm/motorola.c
index afb57eeafdcb..bdb11103694b 100644
--- a/arch/m68k/mm/motorola.c
+++ b/arch/m68k/mm/motorola.c
@@ -203,7 +203,7 @@ void __init paging_init(void)
 {
         int chunk;
         unsigned long mem_avail = 0;
-        unsigned long zones_size[3] = { 0, };
+        unsigned long zones_size[MAX_NR_ZONES] = { 0, };
 
 #ifdef DEBUG
         {
@@ -257,12 +257,12 @@ void __init paging_init(void)
 #ifdef DEBUG
         printk ("before free_area_init\n");
 #endif
-        zones_size[0] = (mach_max_dma_address < (unsigned long)high_memory ?
-                         (mach_max_dma_address+1) : (unsigned long)high_memory);
-        zones_size[1] = (unsigned long)high_memory - zones_size[0];
+        zones_size[ZONE_DMA] = (mach_max_dma_address < (unsigned long)high_memory ?
+                                (mach_max_dma_address+1) : (unsigned long)high_memory);
+        zones_size[ZONE_NORMAL] = (unsigned long)high_memory - zones_size[0];
 
-        zones_size[0] = (zones_size[0] - PAGE_OFFSET) >> PAGE_SHIFT;
-        zones_size[1] >>= PAGE_SHIFT;
+        zones_size[ZONE_DMA] = (zones_size[ZONE_DMA] - PAGE_OFFSET) >> PAGE_SHIFT;
+        zones_size[ZONE_NORMAL] >>= PAGE_SHIFT;
 
         free_area_init(zones_size);
 }
diff --git a/arch/m68k/mm/sun3mmu.c b/arch/m68k/mm/sun3mmu.c
index a47be196a47c..ac6640ade0b1 100644
--- a/arch/m68k/mm/sun3mmu.c
+++ b/arch/m68k/mm/sun3mmu.c
@@ -46,7 +46,7 @@ void __init paging_init(void)
         unsigned long address;
         unsigned long next_pgtable;
         unsigned long bootmem_end;
-        unsigned long zones_size[3] = {0, 0, 0};
+        unsigned long zones_size[MAX_NR_ZONES] = { 0, };
         unsigned long size;
 
 
@@ -92,8 +92,7 @@ void __init paging_init(void)
         current->mm = NULL;
 
         /* memory sizing is a hack stolen from motorola.c..  hope it works for us */
-        zones_size[0] = ((unsigned long)high_memory - PAGE_OFFSET) >> PAGE_SHIFT;
-        zones_size[1] = 0;
+        zones_size[ZONE_DMA] = ((unsigned long)high_memory - PAGE_OFFSET) >> PAGE_SHIFT;
 
         free_area_init(zones_size);
 
diff --git a/arch/m68knommu/kernel/signal.c b/arch/m68knommu/kernel/signal.c
index e1b3aa39e270..8e2c5a88efa7 100644
--- a/arch/m68knommu/kernel/signal.c
+++ b/arch/m68knommu/kernel/signal.c
@@ -553,7 +553,7 @@ get_sigframe(struct k_sigaction *ka, struct pt_regs *regs, size_t frame_size)
 
         /* This is the X/Open sanctioned signal stack switching.  */
         if (ka->sa.sa_flags & SA_ONSTACK) {
-                if (!on_sig_stack(usp))
+                if (!sas_ss_flags(usp))
                         usp = current->sas_ss_sp + current->sas_ss_size;
         }
         return (void *)((usp - frame_size) & -8UL);
diff --git a/arch/mips/kernel/scall32-o32.S b/arch/mips/kernel/scall32-o32.S
index a0ac0e5f61ad..2d2fdf77e308 100644
--- a/arch/mips/kernel/scall32-o32.S
+++ b/arch/mips/kernel/scall32-o32.S
@@ -497,7 +497,7 @@ einval:	li	v0, -EINVAL
         sys     sys_sched_get_priority_min 1
         sys     sys_sched_rr_get_interval 2     /* 4165 */
         sys     sys_nanosleep,          2
-        sys     sys_mremap,             4
+        sys     sys_mremap,             5
         sys     sys_accept              3
         sys     sys_bind                3
         sys     sys_connect             3       /* 4170 */
diff --git a/arch/mips/kernel/sysirix.c b/arch/mips/kernel/sysirix.c
index 5407b784cd01..19e1ef43eb4b 100644
--- a/arch/mips/kernel/sysirix.c
+++ b/arch/mips/kernel/sysirix.c
@@ -694,7 +694,7 @@ asmlinkage int irix_statfs(const char __user *path,
         if (error)
                 goto out;
 
-        error = vfs_statfs(nd.dentry->d_inode->i_sb, &kbuf);
+        error = vfs_statfs(nd.dentry, &kbuf);
         if (error)
                 goto dput_and_out;
 
@@ -732,7 +732,7 @@ asmlinkage int irix_fstatfs(unsigned int fd, struct irix_statfs __user *buf)
                 goto out;
         }
 
-        error = vfs_statfs(file->f_dentry->d_inode->i_sb, &kbuf);
+        error = vfs_statfs(file->f_dentry, &kbuf);
         if (error)
                 goto out_f;
 
@@ -1360,7 +1360,7 @@ asmlinkage int irix_statvfs(char __user *fname, struct irix_statvfs __user *buf)
         error = user_path_walk(fname, &nd);
         if (error)
                 goto out;
-        error = vfs_statfs(nd.dentry->d_inode->i_sb, &kbuf);
+        error = vfs_statfs(nd.dentry, &kbuf);
         if (error)
                 goto dput_and_out;
 
@@ -1406,7 +1406,7 @@ asmlinkage int irix_fstatvfs(int fd, struct irix_statvfs __user *buf)
                 error = -EBADF;
                 goto out;
         }
-        error = vfs_statfs(file->f_dentry->d_inode->i_sb, &kbuf);
+        error = vfs_statfs(file->f_dentry, &kbuf);
         if (error)
                 goto out_f;
 
@@ -1611,7 +1611,7 @@ asmlinkage int irix_statvfs64(char __user *fname, struct irix_statvfs64 __user *
         error = user_path_walk(fname, &nd);
         if (error)
                 goto out;
-        error = vfs_statfs(nd.dentry->d_inode->i_sb, &kbuf);
+        error = vfs_statfs(nd.dentry, &kbuf);
         if (error)
                 goto dput_and_out;
 
@@ -1658,7 +1658,7 @@ asmlinkage int irix_fstatvfs64(int fd, struct irix_statvfs __user *buf)
                 error = -EBADF;
                 goto out;
         }
-        error = vfs_statfs(file->f_dentry->d_inode->i_sb, &kbuf);
+        error = vfs_statfs(file->f_dentry, &kbuf);
         if (error)
                 goto out_f;
 
diff --git a/arch/parisc/hpux/sys_hpux.c b/arch/parisc/hpux/sys_hpux.c
index 05273ccced0e..cb69727027ae 100644
--- a/arch/parisc/hpux/sys_hpux.c
+++ b/arch/parisc/hpux/sys_hpux.c
@@ -145,7 +145,7 @@ static int hpux_ustat(dev_t dev, struct hpux_ustat __user *ubuf)
         s = user_get_super(dev);
         if (s == NULL)
                 goto out;
-        err = vfs_statfs(s, &sbuf);
+        err = vfs_statfs(s->s_root, &sbuf);
         drop_super(s);
         if (err)
                 goto out;
@@ -186,12 +186,12 @@ struct hpux_statfs {
      int16_t f_pad;
 };
 
-static int vfs_statfs_hpux(struct super_block *sb, struct hpux_statfs *buf)
+static int vfs_statfs_hpux(struct dentry *dentry, struct hpux_statfs *buf)
 {
         struct kstatfs st;
         int retval;
         
-        retval = vfs_statfs(sb, &st);
+        retval = vfs_statfs(dentry, &st);
         if (retval)
                 return retval;
 
@@ -219,7 +219,7 @@ asmlinkage long hpux_statfs(const char __user *path,
         error = user_path_walk(path, &nd);
         if (!error) {
                 struct hpux_statfs tmp;
-                error = vfs_statfs_hpux(nd.dentry->d_inode->i_sb, &tmp);
+                error = vfs_statfs_hpux(nd.dentry, &tmp);
                 if (!error && copy_to_user(buf, &tmp, sizeof(tmp)))
                         error = -EFAULT;
                 path_release(&nd);
@@ -237,7 +237,7 @@ asmlinkage long hpux_fstatfs(unsigned int fd, struct hpux_statfs __user * buf)
         file = fget(fd);
         if (!file)
                 goto out;
-        error = vfs_statfs_hpux(file->f_dentry->d_inode->i_sb, &tmp);
+        error = vfs_statfs_hpux(file->f_dentry, &tmp);
         if (!error && copy_to_user(buf, &tmp, sizeof(tmp)))
                 error = -EFAULT;
         fput(file);
diff --git a/arch/parisc/kernel/signal.c b/arch/parisc/kernel/signal.c
index 05767e83cf2d..cc38edfd90c5 100644
--- a/arch/parisc/kernel/signal.c
+++ b/arch/parisc/kernel/signal.c
@@ -248,7 +248,7 @@ get_sigframe(struct k_sigaction *ka, unsigned long sp, size_t frame_size)
         DBG(1,"get_sigframe: ka = %#lx, sp = %#lx, frame_size = %#lx\n",
                         (unsigned long)ka, sp, frame_size);
         
-        if ((ka->sa.sa_flags & SA_ONSTACK) != 0 && ! on_sig_stack(sp))
+        if ((ka->sa.sa_flags & SA_ONSTACK) != 0 && ! sas_ss_flags(sp))
                 sp = current->sas_ss_sp; /* Stacks grow up! */
 
         DBG(1,"get_sigframe: Returning sp = %#lx\n", (unsigned long)sp);
diff --git a/arch/powerpc/Kconfig b/arch/powerpc/Kconfig
index 6729c98b66f9..e922a88b2bad 100644
--- a/arch/powerpc/Kconfig
+++ b/arch/powerpc/Kconfig
@@ -45,6 +45,10 @@ config GENERIC_CALIBRATE_DELAY
         bool
         default y
 
+config GENERIC_FIND_NEXT_BIT
+        bool
+        default y
+
 config PPC
         bool
         default y
@@ -137,6 +141,15 @@ config PPC_85xx
         select FSL_SOC
         select 85xx
 
+config PPC_86xx
+        bool "Freescale 86xx"
+        select 6xx
+        select FSL_SOC
+        select PPC_FPU
+        select ALTIVEC
+        help
+          The Freescale E600 SoCs have 74xx cores.
+
 config 40x
         bool "AMCC 40x"
 
@@ -336,7 +349,7 @@ endchoice
 
 config PPC_PSERIES
         depends on PPC_MULTIPLATFORM && PPC64
-        bool "  IBM pSeries & new (POWER5-based) iSeries"
+        bool "IBM pSeries & new (POWER5-based) iSeries"
         select PPC_I8259
         select PPC_RTAS
         select RTAS_ERROR_LOGGING
@@ -344,7 +357,7 @@ config PPC_PSERIES
         default y
 
 config PPC_CHRP
-        bool "  Common Hardware Reference Platform (CHRP) based machines"
+        bool "Common Hardware Reference Platform (CHRP) based machines"
         depends on PPC_MULTIPLATFORM && PPC32
         select PPC_I8259
         select PPC_INDIRECT_PCI
@@ -354,7 +367,7 @@ config PPC_CHRP
         default y
 
 config PPC_PMAC
-        bool "  Apple PowerMac based machines"
+        bool "Apple PowerMac based machines"
         depends on PPC_MULTIPLATFORM
         select PPC_INDIRECT_PCI if PPC32
         select PPC_MPC106 if PPC32
@@ -370,7 +383,7 @@ config PPC_PMAC64
         default y
 
 config PPC_PREP
-        bool "  PowerPC Reference Platform (PReP) based machines"
+        bool "PowerPC Reference Platform (PReP) based machines"
         depends on PPC_MULTIPLATFORM && PPC32 && BROKEN
         select PPC_I8259
         select PPC_INDIRECT_PCI
@@ -379,7 +392,7 @@ config PPC_PREP
 
 config PPC_MAPLE
         depends on PPC_MULTIPLATFORM && PPC64
-        bool "  Maple 970FX Evaluation Board"
+        bool "Maple 970FX Evaluation Board"
         select U3_DART
         select MPIC_BROKEN_U3
         select GENERIC_TBSYNC
@@ -391,8 +404,18 @@ config PPC_MAPLE
           For more informations, refer to <http://www.970eval.com>
 
 config PPC_CELL
-        bool "  Cell Broadband Processor Architecture"
+        bool
+        default n
+
+config PPC_CELL_NATIVE
+        bool
+        select PPC_CELL
+        default n
+
+config PPC_IBM_CELL_BLADE
+        bool "  IBM Cell Blade"
         depends on PPC_MULTIPLATFORM && PPC64
+        select PPC_CELL_NATIVE
         select PPC_RTAS
         select MMIO_NVRAM
         select PPC_UDBG_16550
@@ -439,11 +462,6 @@ config MPIC_BROKEN_U3
         depends on PPC_MAPLE
         default y
 
-config CELL_IIC
-        depends on PPC_CELL
-        bool
-        default y
-
 config IBMVIO
         depends on PPC_PSERIES || PPC_ISERIES
         bool
@@ -545,6 +563,7 @@ source arch/powerpc/platforms/embedded6xx/Kconfig
 source arch/powerpc/platforms/4xx/Kconfig
 source arch/powerpc/platforms/83xx/Kconfig
 source arch/powerpc/platforms/85xx/Kconfig
+source arch/powerpc/platforms/86xx/Kconfig
 source arch/powerpc/platforms/8xx/Kconfig
 source arch/powerpc/platforms/cell/Kconfig
 
@@ -699,7 +718,6 @@ config PPC_64K_PAGES
 config SCHED_SMT
         bool "SMT (Hyperthreading) scheduler support"
         depends on PPC64 && SMP
-        default off
         help
           SMT scheduler support improves the CPU scheduler's decision making
           when dealing with POWER5 cpus at a cost of slightly increased
@@ -776,6 +794,7 @@ config GENERIC_ISA_DMA
 
 config PPC_I8259
         bool
+        default y if MPC8641_HPCN
         default n
 
 config PPC_INDIRECT_PCI
@@ -798,8 +817,8 @@ config MCA
         bool
 
 config PCI
-        bool "PCI support" if 40x || CPM2 || PPC_83xx || PPC_85xx || PPC_MPC52xx || (EMBEDDED && PPC_ISERIES)
-        default y if !40x && !CPM2 && !8xx && !APUS && !PPC_83xx && !PPC_85xx
+        bool "PCI support" if 40x || CPM2 || PPC_83xx || PPC_85xx || PPC_86xx || PPC_MPC52xx || (EMBEDDED && PPC_ISERIES)
+        default y if !40x && !CPM2 && !8xx && !APUS && !PPC_83xx && !PPC_85xx && !PPC_86xx
         default PCI_PERMEDIA if !4xx && !CPM2 && !8xx && APUS
         default PCI_QSPAN if !4xx && !CPM2 && 8xx
         help
@@ -827,12 +846,12 @@ config PCI_8260
         default y
 
 config 8260_PCI9
-        bool "  Enable workaround for MPC826x erratum PCI 9"
+        bool "Enable workaround for MPC826x erratum PCI 9"
         depends on PCI_8260 && !ADS8272
         default y
 
 choice
-        prompt "  IDMA channel for PCI 9 workaround"
+        prompt "IDMA channel for PCI 9 workaround"
         depends on 8260_PCI9
 
 config 8260_PCI9_IDMA1
@@ -849,6 +868,8 @@ config 8260_PCI9_IDMA4
 
 endchoice
 
+source "drivers/pci/pcie/Kconfig"
+
 source "drivers/pci/Kconfig"
 
 source "drivers/pcmcia/Kconfig"
diff --git a/arch/powerpc/Kconfig.debug b/arch/powerpc/Kconfig.debug
index 8d48e9e7162a..c69006ae8246 100644
--- a/arch/powerpc/Kconfig.debug
+++ b/arch/powerpc/Kconfig.debug
@@ -110,13 +110,16 @@ config SERIAL_TEXT_DEBUG
         depends on 4xx || LOPEC || MV64X60 || PPLUS || PRPMC800 || \
                 PPC_GEN550 || PPC_MPC52xx
 
+config PPC_EARLY_DEBUG
+        bool "Early debugging (dangerous)"
+
 choice
-        prompt "Early debugging (dangerous)"
-        bool
-        optional
+        prompt "Early debugging console"
+        depends on PPC_EARLY_DEBUG
         help
-          Enable early debugging. Careful, if you enable debugging for the
-          wrong type of machine your kernel _will not boot_.
+          Use the selected console for early debugging. Careful, if you
+          enable debugging for the wrong type of machine your kernel
+          _will not boot_.
 
 config PPC_EARLY_DEBUG_LPAR
         bool "LPAR HV Console"
diff --git a/arch/powerpc/Makefile b/arch/powerpc/Makefile
index ed5b26aa8be3..01667d1d571d 100644
--- a/arch/powerpc/Makefile
+++ b/arch/powerpc/Makefile
@@ -108,7 +108,6 @@ ifeq ($(CONFIG_6xx),y)
 CFLAGS          += -mcpu=powerpc
 endif
 
-cpu-as-$(CONFIG_PPC64BRIDGE)    += -Wa,-mppc64bridge
 cpu-as-$(CONFIG_4xx)            += -Wa,-m405
 cpu-as-$(CONFIG_6xx)            += -Wa,-maltivec
 cpu-as-$(CONFIG_POWER4)         += -Wa,-maltivec
diff --git a/arch/powerpc/boot/Makefile b/arch/powerpc/boot/Makefile
index 840ae595a617..d961bfeed05f 100644
--- a/arch/powerpc/boot/Makefile
+++ b/arch/powerpc/boot/Makefile
@@ -29,8 +29,8 @@ 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
+zlib       := inffast.c inflate.c inftrees.c
+zlibheader := inffast.h inffixed.h inflate.h inftrees.h infutil.h
 zliblinuxheader := zlib.h zconf.h zutil.h
 
 $(addprefix $(obj)/,$(zlib) main.o): $(addprefix $(obj)/,$(zliblinuxheader)) $(addprefix $(obj)/,$(zlibheader))
diff --git a/arch/powerpc/boot/main.c b/arch/powerpc/boot/main.c
index 816446f0e497..b66634c9ea34 100644
--- a/arch/powerpc/boot/main.c
+++ b/arch/powerpc/boot/main.c
@@ -33,6 +33,14 @@ extern char _vmlinux_end[];
 extern char _initrd_start[];
 extern char _initrd_end[];
 
+/* A buffer that may be edited by tools operating on a zImage binary so as to
+ * edit the command line passed to vmlinux (by setting /chosen/bootargs).
+ * The buffer is put in it's own section so that tools may locate it easier.
+ */
+static char builtin_cmdline[512]
+        __attribute__((section("__builtin_cmdline")));
+
+
 struct addr_range {
         unsigned long addr;
         unsigned long size;
@@ -204,6 +212,23 @@ static int is_elf32(void *hdr)
         return 1;
 }
 
+void export_cmdline(void* chosen_handle)
+{
+        int len;
+        char cmdline[2] = { 0, 0 };
+
+        if (builtin_cmdline[0] == 0)
+                return;
+
+        len = getprop(chosen_handle, "bootargs", cmdline, sizeof(cmdline));
+        if (len > 0 && cmdline[0] != 0)
+                return;
+
+        setprop(chosen_handle, "bootargs", builtin_cmdline,
+                strlen(builtin_cmdline) + 1);
+}
+
+
 void start(unsigned long a1, unsigned long a2, void *promptr, void *sp)
 {
         int len;
@@ -289,6 +314,8 @@ void start(unsigned long a1, unsigned long a2, void *promptr, void *sp)
                 memmove((void *)vmlinux.addr,(void *)vmlinuz.addr,vmlinuz.size);
         }
 
+        export_cmdline(chosen_handle);
+
         /* Skip over the ELF header */
 #ifdef DEBUG
         printf("... skipping 0x%lx bytes of ELF header\n\r",
diff --git a/arch/powerpc/boot/prom.h b/arch/powerpc/boot/prom.h
index 3e2ddd4a5a81..a57b184c564f 100644
--- a/arch/powerpc/boot/prom.h
+++ b/arch/powerpc/boot/prom.h
@@ -31,4 +31,11 @@ static inline int getprop(void *phandle, const char *name,
         return call_prom("getprop", 4, 1, phandle, name, buf, buflen);
 }
 
+
+static inline int setprop(void *phandle, const char *name,
+                          void *buf, int buflen)
+{
+        return call_prom("setprop", 4, 1, phandle, name, buf, buflen);
+}
+
 #endif                          /* _PPC_BOOT_PROM_H_ */
diff --git a/arch/powerpc/configs/cell_defconfig b/arch/powerpc/configs/cell_defconfig
index dbe421dc3c11..b8b8d4675dc0 100644
--- a/arch/powerpc/configs/cell_defconfig
+++ b/arch/powerpc/configs/cell_defconfig
@@ -1,7 +1,7 @@
 #
 # Automatically generated make config: don't edit
-# Linux kernel version: 2.6.16
-# Thu Mar 23 20:48:09 2006
+# Linux kernel version: 2.6.17
+# Mon Jun 19 17:23:03 2006
 #
 CONFIG_PPC64=y
 CONFIG_64BIT=y
@@ -11,6 +11,7 @@ CONFIG_GENERIC_HARDIRQS=y
 CONFIG_RWSEM_XCHGADD_ALGORITHM=y
 CONFIG_GENERIC_HWEIGHT=y
 CONFIG_GENERIC_CALIBRATE_DELAY=y
+CONFIG_GENERIC_FIND_NEXT_BIT=y
 CONFIG_PPC=y
 CONFIG_EARLY_PRINTK=y
 CONFIG_COMPAT=y
@@ -55,7 +56,7 @@ CONFIG_SYSCTL=y
 # CONFIG_AUDIT is not set
 CONFIG_IKCONFIG=y
 CONFIG_IKCONFIG_PROC=y
-# CONFIG_CPUSETS is not set
+CONFIG_CPUSETS=y
 # CONFIG_RELAY is not set
 CONFIG_INITRAMFS_SOURCE=""
 CONFIG_CC_OPTIMIZE_FOR_SIZE=y
@@ -116,13 +117,15 @@ CONFIG_PPC_MULTIPLATFORM=y
 # CONFIG_PPC_PMAC is not set
 # CONFIG_PPC_MAPLE is not set
 CONFIG_PPC_CELL=y
+CONFIG_PPC_CELL_NATIVE=y
+CONFIG_PPC_IBM_CELL_BLADE=y
+CONFIG_PPC_SYSTEMSIM=y
 # CONFIG_U3_DART is not set
 CONFIG_PPC_RTAS=y
 # CONFIG_RTAS_ERROR_LOGGING is not set
 CONFIG_RTAS_PROC=y
 CONFIG_RTAS_FLASH=y
 CONFIG_MMIO_NVRAM=y
-CONFIG_CELL_IIC=y
 # CONFIG_PPC_MPC106 is not set
 # CONFIG_PPC_970_NAP is not set
 # CONFIG_CPU_FREQ is not set
@@ -132,7 +135,9 @@ CONFIG_CELL_IIC=y
 # Cell Broadband Engine options
 #
 CONFIG_SPU_FS=m
+CONFIG_SPU_BASE=y
 CONFIG_SPUFS_MMAP=y
+CONFIG_CBE_RAS=y
 
 #
 # Kernel options
@@ -152,20 +157,24 @@ CONFIG_FORCE_MAX_ZONEORDER=13
 CONFIG_KEXEC=y
 # CONFIG_CRASH_DUMP is not set
 CONFIG_IRQ_ALL_CPUS=y
-# CONFIG_NUMA is not set
+CONFIG_NUMA=y
+CONFIG_NODES_SHIFT=4
 CONFIG_ARCH_SELECT_MEMORY_MODEL=y
-CONFIG_ARCH_FLATMEM_ENABLE=y
 CONFIG_ARCH_SPARSEMEM_ENABLE=y
 CONFIG_SELECT_MEMORY_MODEL=y
 # CONFIG_FLATMEM_MANUAL is not set
 # CONFIG_DISCONTIGMEM_MANUAL is not set
 CONFIG_SPARSEMEM_MANUAL=y
 CONFIG_SPARSEMEM=y
+CONFIG_NEED_MULTIPLE_NODES=y
 CONFIG_HAVE_MEMORY_PRESENT=y
 # CONFIG_SPARSEMEM_STATIC is not set
 CONFIG_SPARSEMEM_EXTREME=y
-# CONFIG_MEMORY_HOTPLUG is not set
+CONFIG_MEMORY_HOTPLUG=y
 CONFIG_SPLIT_PTLOCK_CPUS=4
+CONFIG_MIGRATION=y
+CONFIG_HAVE_ARCH_EARLY_PFN_TO_NID=y
+CONFIG_ARCH_MEMORY_PROBE=y
 # CONFIG_PPC_64K_PAGES is not set
 CONFIG_SCHED_SMT=y
 CONFIG_PROC_DEVICETREE=y
@@ -182,6 +191,7 @@ CONFIG_GENERIC_ISA_DMA=y
 # CONFIG_PPC_INDIRECT_PCI is not set
 CONFIG_PCI=y
 CONFIG_PCI_DOMAINS=y
+CONFIG_PCIEPORTBUS=y
 # CONFIG_PCI_DEBUG is not set
 
 #
@@ -476,7 +486,7 @@ CONFIG_DM_MULTIPATH=m
 #
 CONFIG_NETDEVICES=y
 # CONFIG_DUMMY is not set
-# CONFIG_BONDING is not set
+CONFIG_BONDING=y
 # CONFIG_EQUALIZER is not set
 # CONFIG_TUN is not set
 
@@ -624,6 +634,7 @@ CONFIG_SERIAL_NONSTANDARD=y
 # CONFIG_N_HDLC is not set
 # CONFIG_SPECIALIX is not set
 # CONFIG_SX is not set
+# CONFIG_RIO is not set
 # CONFIG_STALDRV is not set
 
 #
@@ -766,6 +777,7 @@ CONFIG_I2C_ALGOBIT=y
 # Multimedia devices
 #
 # CONFIG_VIDEO_DEV is not set
+CONFIG_VIDEO_V4L2=y
 
 #
 # Digital Video Broadcasting Devices
@@ -1054,11 +1066,7 @@ CONFIG_DEBUGGER=y
 # CONFIG_XMON is not set
 CONFIG_IRQSTACKS=y
 # CONFIG_BOOTX_TEXT 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
+# CONFIG_PPC_EARLY_DEBUG is not set
 
 #
 # Security options
diff --git a/arch/powerpc/configs/mpc85xx_cds_defconfig b/arch/powerpc/configs/mpc85xx_cds_defconfig
new file mode 100644
index 000000000000..9bb022a523fe
--- /dev/null
+++ b/arch/powerpc/configs/mpc85xx_cds_defconfig
@@ -0,0 +1,846 @@
+#
+# Automatically generated make config: don't edit
+# Linux kernel version: 2.6.16
+# Sun Apr  2 11:23:42 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_HWEIGHT=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 is not set
+
+#
+# Processor support
+#
+# CONFIG_CLASSIC32 is not set
+# CONFIG_PPC_52xx is not set
+# CONFIG_PPC_82xx is not set
+# CONFIG_PPC_83xx is not set
+CONFIG_PPC_85xx=y
+# CONFIG_40x is not set
+# CONFIG_44x is not set
+# CONFIG_8xx is not set
+# CONFIG_E200 is not set
+CONFIG_85xx=y
+CONFIG_E500=y
+CONFIG_BOOKE=y
+CONFIG_FSL_BOOKE=y
+# CONFIG_PHYS_64BIT is not set
+CONFIG_SPE=y
+
+#
+# Code maturity level options
+#
+CONFIG_EXPERIMENTAL=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_RELAY is not set
+CONFIG_INITRAMFS_SOURCE=""
+# CONFIG_CC_OPTIMIZE_FOR_SIZE is not set
+CONFIG_EMBEDDED=y
+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
+CONFIG_SHMEM=y
+CONFIG_SLAB=y
+# CONFIG_TINY_SHMEM is not set
+CONFIG_BASE_SMALL=0
+# CONFIG_SLOB is not set
+
+#
+# Loadable module support
+#
+# CONFIG_MODULES is not set
+
+#
+# Block layer
+#
+# CONFIG_LBD is not set
+# CONFIG_BLK_DEV_IO_TRACE is not set
+# CONFIG_LSF 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_MPIC=y
+# CONFIG_WANT_EARLY_SERIAL is not set
+
+#
+# Platform support
+#
+# CONFIG_MPC8540_ADS is not set
+CONFIG_MPC85xx_CDS=y
+CONFIG_MPC8540=y
+CONFIG_PPC_INDIRECT_PCI_BE=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=y
+CONFIG_MATH_EMULATION=y
+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 is not set
+CONFIG_ISA_DMA_API=y
+
+#
+# Bus options
+#
+CONFIG_PPC_I8259=y
+CONFIG_PPC_INDIRECT_PCI=y
+CONFIG_FSL_SOC=y
+CONFIG_PCI=y
+CONFIG_PCI_DOMAINS=y
+# CONFIG_PCI_DEBUG 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_NETDEBUG is not set
+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_XFRM_TUNNEL 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_INET6_XFRM_TUNNEL is not set
+# CONFIG_INET6_TUNNEL 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
+
+#
+# TIPC Configuration (EXPERIMENTAL)
+#
+# CONFIG_TIPC 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
+# CONFIG_DEBUG_DRIVER 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=y
+CONFIG_BLK_DEV_IDE=y
+
+#
+# Please see Documentation/ide.txt for help/info on IDE drives
+#
+# CONFIG_BLK_DEV_IDE_SATA is not set
+# CONFIG_BLK_DEV_IDEDISK is not set
+# CONFIG_IDEDISK_MULTI_MODE is not set
+# CONFIG_BLK_DEV_IDECD is not set
+# CONFIG_BLK_DEV_IDETAPE is not set
+# CONFIG_BLK_DEV_IDEFLOPPY is not set
+# CONFIG_IDE_TASK_IOCTL is not set
+
+#
+# IDE chipset support/bugfixes
+#
+CONFIG_IDE_GENERIC=y
+CONFIG_BLK_DEV_IDEPCI=y
+CONFIG_IDEPCI_SHARE_IRQ=y
+# CONFIG_BLK_DEV_OFFBOARD is not set
+CONFIG_BLK_DEV_GENERIC=y
+# CONFIG_BLK_DEV_OPTI621 is not set
+# CONFIG_BLK_DEV_SL82C105 is not set
+CONFIG_BLK_DEV_IDEDMA_PCI=y
+# CONFIG_BLK_DEV_IDEDMA_FORCED is not set
+# CONFIG_IDEDMA_PCI_AUTO is not set
+# CONFIG_BLK_DEV_AEC62XX is not set
+# CONFIG_BLK_DEV_ALI15X3 is not set
+# CONFIG_BLK_DEV_AMD74XX is not set
+# CONFIG_BLK_DEV_CMD64X is not set
+# CONFIG_BLK_DEV_TRIFLEX is not set
+# CONFIG_BLK_DEV_CY82C693 is not set
+# CONFIG_BLK_DEV_CS5520 is not set
+# CONFIG_BLK_DEV_CS5530 is not set
+# CONFIG_BLK_DEV_HPT34X is not set
+# CONFIG_BLK_DEV_HPT366 is not set
+# CONFIG_BLK_DEV_SC1200 is not set
+# CONFIG_BLK_DEV_PIIX is not set
+# CONFIG_BLK_DEV_IT821X is not set
+# CONFIG_BLK_DEV_NS87415 is not set
+# CONFIG_BLK_DEV_PDC202XX_OLD is not set
+# CONFIG_BLK_DEV_PDC202XX_NEW is not set
+# CONFIG_BLK_DEV_SVWKS is not set
+# CONFIG_BLK_DEV_SIIMAGE is not set
+# CONFIG_BLK_DEV_SLC90E66 is not set
+# CONFIG_BLK_DEV_TRM290 is not set
+CONFIG_BLK_DEV_VIA82CXXX=y
+# CONFIG_IDE_ARM is not set
+CONFIG_BLK_DEV_IDEDMA=y
+# CONFIG_IDEDMA_IVB is not set
+# CONFIG_IDEDMA_AUTO is not set
+# CONFIG_BLK_DEV_HD 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 is not set
+# 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 is not set
+
+#
+# Ethernet (1000 Mbit)
+#
+# CONFIG_ACENIC is not set
+# CONFIG_DL2K is not set
+CONFIG_E1000=y
+CONFIG_E1000_NAPI=y
+# CONFIG_E1000_DISABLE_PACKET_SPLIT 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_TIGON3 is not set
+# CONFIG_BNX2 is not set
+CONFIG_GIANFAR=y
+CONFIG_GFAR_NAPI=y
+
+#
+# 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_PCI=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_SERIAL_JSM is not set
+CONFIG_UNIX98_PTYS=y
+CONFIG_LEGACY_PTYS=y
+CONFIG_LEGACY_PTY_COUNT=256
+
+#
+# IPMI
+#
+# CONFIG_IPMI_HANDLER is not set
+
+#
+# Watchdog Cards
+#
+# CONFIG_WATCHDOG 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 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
+
+#
+# Hardware Monitoring support
+#
+CONFIG_HWMON=y
+# CONFIG_HWMON_VID is not set
+# CONFIG_SENSORS_F71805F is not set
+# CONFIG_HWMON_DEBUG_CHIP is not set
+
+#
+# Misc devices
+#
+
+#
+# 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_ARCH_HAS_EHCI=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
+
+#
+# LED devices
+#
+# CONFIG_NEW_LEDS is not set
+
+#
+# InfiniBand support
+#
+# CONFIG_INFINIBAND is not set
+
+#
+# EDAC - error detection and reporting (RAS) (EXPERIMENTAL)
+#
+
+#
+# Real Time Clock
+#
+# CONFIG_RTC_CLASS is not set
+
+#
+# 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_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 is not set
+# CONFIG_NFS_V4 is not set
+# CONFIG_NFS_DIRECTIO is not set
+# CONFIG_NFSD is not set
+CONFIG_ROOT_NFS=y
+CONFIG_LOCKD=y
+CONFIG_NFS_COMMON=y
+CONFIG_SUNRPC=y
+# CONFIG_RPCSEC_GSS_KRB5 is not set
+# 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_KARMA_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=y
+CONFIG_LOG_BUF_SHIFT=14
+CONFIG_DETECT_SOFTLOCKUP=y
+# CONFIG_SCHEDSTATS is not set
+# CONFIG_DEBUG_SLAB is not set
+CONFIG_DEBUG_MUTEXES=y
+# CONFIG_DEBUG_SPINLOCK is not set
+# CONFIG_DEBUG_SPINLOCK_SLEEP is not set
+# CONFIG_DEBUG_KOBJECT is not set
+# CONFIG_DEBUG_INFO is not set
+# CONFIG_DEBUG_FS is not set
+# CONFIG_DEBUG_VM is not set
+# CONFIG_UNWIND_INFO is not set
+CONFIG_FORCED_INLINING=y
+# CONFIG_RCU_TORTURE_TEST is not set
+# CONFIG_DEBUGGER is not set
+# CONFIG_BDI_SWITCH is not set
+# CONFIG_BOOTX_TEXT 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 is not set
+
+#
+# Hardware crypto devices
+#
diff --git a/arch/powerpc/configs/mpc8641_hpcn_defconfig b/arch/powerpc/configs/mpc8641_hpcn_defconfig
new file mode 100644
index 000000000000..d7a30f9bc535
--- /dev/null
+++ b/arch/powerpc/configs/mpc8641_hpcn_defconfig
@@ -0,0 +1,921 @@
+#
+# Automatically generated make config: don't edit
+# Linux kernel version: 2.6.17-rc3
+# Fri Jun 16 10:47:09 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_HWEIGHT=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=y
+# CONFIG_DEFAULT_UIMAGE is not set
+
+#
+# Processor support
+#
+# CONFIG_CLASSIC32 is not set
+# CONFIG_PPC_52xx is not set
+# CONFIG_PPC_82xx is not set
+# CONFIG_PPC_83xx is not set
+# CONFIG_PPC_85xx is not set
+CONFIG_PPC_86xx=y
+# CONFIG_40x is not set
+# CONFIG_44x is not set
+# CONFIG_8xx is not set
+# CONFIG_E200 is not set
+CONFIG_6xx=y
+CONFIG_PPC_FPU=y
+CONFIG_ALTIVEC=y
+CONFIG_PPC_STD_MMU=y
+CONFIG_PPC_STD_MMU_32=y
+CONFIG_SMP=y
+CONFIG_NR_CPUS=2
+
+#
+# Code maturity level options
+#
+CONFIG_EXPERIMENTAL=y
+CONFIG_LOCK_KERNEL=y
+CONFIG_INIT_ENV_ARG_LIMIT=32
+
+#
+# General setup
+#
+CONFIG_LOCALVERSION=""
+# CONFIG_LOCALVERSION_AUTO is not set
+# CONFIG_SWAP is not set
+# CONFIG_SYSVIPC is not set
+# CONFIG_POSIX_MQUEUE is not set
+# CONFIG_BSD_PROCESS_ACCT is not set
+CONFIG_SYSCTL=y
+# CONFIG_AUDIT is not set
+CONFIG_IKCONFIG=y
+CONFIG_IKCONFIG_PROC=y
+# CONFIG_CPUSETS is not set
+# CONFIG_RELAY is not set
+CONFIG_INITRAMFS_SOURCE=""
+# CONFIG_CC_OPTIMIZE_FOR_SIZE is not set
+CONFIG_EMBEDDED=y
+CONFIG_KALLSYMS=y
+# CONFIG_KALLSYMS_ALL is not set
+CONFIG_KALLSYMS_EXTRA_PASS=y
+CONFIG_HOTPLUG=y
+CONFIG_PRINTK=y
+CONFIG_BUG=y
+# CONFIG_ELF_CORE is not set
+CONFIG_BASE_FULL=y
+CONFIG_FUTEX=y
+CONFIG_EPOLL=y
+CONFIG_SHMEM=y
+# CONFIG_SLAB is not set
+# CONFIG_TINY_SHMEM is not set
+CONFIG_BASE_SMALL=0
+CONFIG_SLOB=y
+
+#
+# Loadable module support
+#
+# CONFIG_MODULES is not set
+
+#
+# Block layer
+#
+# CONFIG_LBD is not set
+# CONFIG_BLK_DEV_IO_TRACE is not set
+# CONFIG_LSF is not set
+
+#
+# IO Schedulers
+#
+CONFIG_IOSCHED_NOOP=y
+# CONFIG_IOSCHED_AS is not set
+CONFIG_IOSCHED_DEADLINE=y
+# CONFIG_IOSCHED_CFQ is not set
+# CONFIG_DEFAULT_AS is not set
+CONFIG_DEFAULT_DEADLINE=y
+# CONFIG_DEFAULT_CFQ is not set
+# CONFIG_DEFAULT_NOOP is not set
+CONFIG_DEFAULT_IOSCHED="deadline"
+CONFIG_MPIC=y
+# CONFIG_WANT_EARLY_SERIAL is not set
+CONFIG_PPC_INDIRECT_PCI_BE=y
+
+#
+# Platform Support
+#
+CONFIG_MPC8641_HPCN=y
+CONFIG_MPC8641=y
+
+#
+# Kernel options
+#
+CONFIG_HIGHMEM=y
+# CONFIG_HZ_100 is not set
+# CONFIG_HZ_250 is not set
+CONFIG_HZ_1000=y
+CONFIG_HZ=1000
+CONFIG_PREEMPT_NONE=y
+# CONFIG_PREEMPT_VOLUNTARY is not set
+# CONFIG_PREEMPT is not set
+CONFIG_PREEMPT_BKL=y
+CONFIG_BINFMT_ELF=y
+# CONFIG_BINFMT_MISC is not set
+# CONFIG_IRQ_ALL_CPUS 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_SECCOMP is not set
+CONFIG_ISA_DMA_API=y
+
+#
+# Bus options
+#
+CONFIG_GENERIC_ISA_DMA=y
+CONFIG_PPC_I8259=y
+CONFIG_PPC_INDIRECT_PCI=y
+CONFIG_FSL_SOC=y
+CONFIG_PCI=y
+CONFIG_PCI_DOMAINS=y
+# CONFIG_PCI_DEBUG 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_NETDEBUG is not set
+CONFIG_PACKET=y
+# CONFIG_PACKET_MMAP is not set
+CONFIG_UNIX=y
+# CONFIG_NET_KEY is not set
+CONFIG_INET=y
+# CONFIG_IP_MULTICAST is not set
+# 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=y
+# CONFIG_NET_IPIP is not set
+# CONFIG_NET_IPGRE is not set
+# CONFIG_ARPD is not set
+# CONFIG_SYN_COOKIES is not set
+# CONFIG_INET_AH is not set
+# CONFIG_INET_ESP is not set
+# CONFIG_INET_IPCOMP is not set
+# CONFIG_INET_XFRM_TUNNEL 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=y
+# CONFIG_IPV6_PRIVACY is not set
+# CONFIG_IPV6_ROUTER_PREF is not set
+# CONFIG_INET6_AH is not set
+# CONFIG_INET6_ESP is not set
+# CONFIG_INET6_IPCOMP is not set
+# CONFIG_INET6_XFRM_TUNNEL is not set
+# CONFIG_INET6_TUNNEL is not set
+# CONFIG_IPV6_TUNNEL 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
+
+#
+# TIPC Configuration (EXPERIMENTAL)
+#
+# CONFIG_TIPC 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=y
+# CONFIG_DEBUG_DRIVER 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=131072
+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=y
+# 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 is not set
+# CONFIG_DAVICOM_PHY is not set
+# CONFIG_QSEMI_PHY is not set
+# CONFIG_LXT_PHY is not set
+# CONFIG_CICADA_PHY is not set
+CONFIG_VITESSE_PHY=y
+
+#
+# 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 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_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=y
+CONFIG_SERIO_I8042=y
+CONFIG_SERIO_SERPORT=y
+# CONFIG_SERIO_PCIPS2 is not set
+CONFIG_SERIO_LIBPS2=y
+# CONFIG_SERIO_RAW is not set
+# CONFIG_GAMEPORT is not set
+
+#
+# Character devices
+#
+CONFIG_VT=y
+CONFIG_VT_CONSOLE=y
+CONFIG_HW_CONSOLE=y
+# CONFIG_SERIAL_NONSTANDARD is not set
+
+#
+# Serial drivers
+#
+CONFIG_SERIAL_8250=y
+CONFIG_SERIAL_8250_CONSOLE=y
+CONFIG_SERIAL_8250_PCI=y
+CONFIG_SERIAL_8250_NR_UARTS=2
+CONFIG_SERIAL_8250_RUNTIME_UARTS=2
+CONFIG_SERIAL_8250_EXTENDED=y
+CONFIG_SERIAL_8250_MANY_PORTS=y
+CONFIG_SERIAL_8250_SHARE_IRQ=y
+CONFIG_SERIAL_8250_DETECT_IRQ=y
+CONFIG_SERIAL_8250_RSA=y
+
+#
+# Non-8250 serial port support
+#
+CONFIG_SERIAL_CORE=y
+CONFIG_SERIAL_CORE_CONSOLE=y
+# CONFIG_SERIAL_JSM is not set
+CONFIG_UNIX98_PTYS=y
+# CONFIG_LEGACY_PTYS is not set
+
+#
+# IPMI
+#
+# CONFIG_IPMI_HANDLER is not set
+
+#
+# Watchdog Cards
+#
+# CONFIG_WATCHDOG is not set
+# CONFIG_NVRAM is not set
+# CONFIG_GEN_RTC 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 is not set
+
+#
+# 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_I2C_SIS5595 is not set
+# CONFIG_I2C_SIS630 is not set
+# CONFIG_I2C_SIS96X 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=y
+# CONFIG_SENSORS_PCF8574 is not set
+# CONFIG_SENSORS_PCA9539 is not set
+# CONFIG_SENSORS_PCF8591 is not set
+# CONFIG_SENSORS_M41T00 is not set
+# CONFIG_SENSORS_MAX6875 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
+
+#
+# SPI support
+#
+# CONFIG_SPI is not set
+# CONFIG_SPI_MASTER is not set
+
+#
+# Dallas's 1-wire bus
+#
+# CONFIG_W1 is not set
+
+#
+# Hardware Monitoring support
+#
+# CONFIG_HWMON is not set
+# CONFIG_HWMON_VID is not set
+
+#
+# Misc devices
+#
+
+#
+# Multimedia devices
+#
+# CONFIG_VIDEO_DEV is not set
+
+#
+# Digital Video Broadcasting Devices
+#
+# CONFIG_DVB is not set
+
+#
+# Graphics support
+#
+# CONFIG_FB is not set
+
+#
+# Console display driver support
+#
+CONFIG_VGA_CONSOLE=y
+# CONFIG_VGACON_SOFT_SCROLLBACK is not set
+CONFIG_DUMMY_CONSOLE=y
+
+#
+# Sound
+#
+# CONFIG_SOUND is not set
+
+#
+# USB support
+#
+CONFIG_USB_ARCH_HAS_HCD=y
+CONFIG_USB_ARCH_HAS_OHCI=y
+CONFIG_USB_ARCH_HAS_EHCI=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
+
+#
+# LED devices
+#
+# CONFIG_NEW_LEDS is not set
+
+#
+# LED drivers
+#
+
+#
+# LED Triggers
+#
+
+#
+# InfiniBand support
+#
+# CONFIG_INFINIBAND is not set
+
+#
+# EDAC - error detection and reporting (RAS) (EXPERIMENTAL)
+#
+
+#
+# Real Time Clock
+#
+# CONFIG_RTC_CLASS is not set
+
+#
+# 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 is not set
+# CONFIG_QUOTA is not set
+# CONFIG_DNOTIFY is not set
+# 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_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 is not set
+# CONFIG_NFS_DIRECTIO is not set
+CONFIG_NFSD=y
+# CONFIG_NFSD_V3 is not set
+CONFIG_NFSD_TCP=y
+CONFIG_ROOT_NFS=y
+CONFIG_LOCKD=y
+CONFIG_LOCKD_V4=y
+CONFIG_EXPORTFS=y
+CONFIG_NFS_COMMON=y
+CONFIG_SUNRPC=y
+# CONFIG_RPCSEC_GSS_KRB5 is not set
+# 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=y
+# CONFIG_BSD_DISKLABEL is not set
+# CONFIG_MINIX_SUBPARTITION is not set
+# CONFIG_SOLARIS_X86_PARTITION is not set
+# CONFIG_UNIXWARE_DISKLABEL is not set
+CONFIG_LDM_PARTITION=y
+# CONFIG_LDM_DEBUG is not set
+# CONFIG_SGI_PARTITION is not set
+# CONFIG_ULTRIX_PARTITION is not set
+# CONFIG_SUN_PARTITION is not set
+# CONFIG_KARMA_PARTITION is not set
+# CONFIG_EFI_PARTITION is not set
+
+#
+# Native Language Support
+#
+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
+
+#
+# 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=y
+CONFIG_LOG_BUF_SHIFT=14
+CONFIG_DETECT_SOFTLOCKUP=y
+# CONFIG_SCHEDSTATS 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
+# CONFIG_DEBUG_HIGHMEM is not set
+# CONFIG_DEBUG_INFO is not set
+# CONFIG_DEBUG_FS is not set
+# CONFIG_DEBUG_VM is not set
+# CONFIG_UNWIND_INFO is not set
+CONFIG_FORCED_INLINING=y
+# CONFIG_RCU_TORTURE_TEST is not set
+# CONFIG_DEBUGGER is not set
+# CONFIG_BDI_SWITCH is not set
+# CONFIG_BOOTX_TEXT 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 is not set
+
+#
+# Hardware crypto devices
+#
diff --git a/arch/powerpc/configs/pmac32_defconfig b/arch/powerpc/configs/pmac32_defconfig
index 57a027971d67..addc79381c3b 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.16-rc6
-# Wed Mar 15 16:21:32 2006
+# Linux kernel version: 2.6.17-rc5
+# Mon May 29 14:47:49 2006
 #
 # CONFIG_PPC64 is not set
 CONFIG_PPC32=y
@@ -9,6 +9,7 @@ CONFIG_PPC_MERGE=y
 CONFIG_MMU=y
 CONFIG_GENERIC_HARDIRQS=y
 CONFIG_RWSEM_XCHGADD_ALGORITHM=y
+CONFIG_GENERIC_HWEIGHT=y
 CONFIG_GENERIC_CALIBRATE_DELAY=y
 CONFIG_PPC=y
 CONFIG_EARLY_PRINTK=y
@@ -27,11 +28,11 @@ CONFIG_CLASSIC32=y
 # CONFIG_PPC_52xx is not set
 # CONFIG_PPC_82xx is not set
 # CONFIG_PPC_83xx is not set
+# CONFIG_PPC_85xx is not set
 # 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_PPC_FPU=y
 CONFIG_ALTIVEC=y
@@ -59,6 +60,7 @@ CONFIG_SYSCTL=y
 # CONFIG_AUDIT is not set
 CONFIG_IKCONFIG=y
 CONFIG_IKCONFIG_PROC=y
+# CONFIG_RELAY is not set
 CONFIG_INITRAMFS_SOURCE=""
 # CONFIG_CC_OPTIMIZE_FOR_SIZE is not set
 # CONFIG_EMBEDDED is not set
@@ -73,10 +75,6 @@ CONFIG_BASE_FULL=y
 CONFIG_FUTEX=y
 CONFIG_EPOLL=y
 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
@@ -88,7 +86,6 @@ CONFIG_BASE_SMALL=0
 CONFIG_MODULES=y
 CONFIG_MODULE_UNLOAD=y
 CONFIG_MODULE_FORCE_UNLOAD=y
-CONFIG_OBSOLETE_MODPARM=y
 # CONFIG_MODVERSIONS is not set
 # CONFIG_MODULE_SRCVERSION_ALL is not set
 CONFIG_KMOD=y
@@ -97,6 +94,8 @@ CONFIG_KMOD=y
 # Block layer
 #
 CONFIG_LBD=y
+# CONFIG_BLK_DEV_IO_TRACE is not set
+CONFIG_LSF=y
 
 #
 # IO Schedulers
@@ -124,6 +123,7 @@ CONFIG_MPIC=y
 # CONFIG_PPC_RTAS is not set
 # CONFIG_MMIO_NVRAM is not set
 CONFIG_PPC_MPC106=y
+# CONFIG_PPC_970_NAP is not set
 CONFIG_CPU_FREQ=y
 CONFIG_CPU_FREQ_TABLE=y
 # CONFIG_CPU_FREQ_DEBUG is not set
@@ -182,7 +182,6 @@ CONFIG_GENERIC_ISA_DMA=y
 CONFIG_PPC_INDIRECT_PCI=y
 CONFIG_PCI=y
 CONFIG_PCI_DOMAINS=y
-CONFIG_PCI_LEGACY_PROC=y
 # CONFIG_PCI_DEBUG is not set
 
 #
@@ -239,7 +238,9 @@ CONFIG_NET=y
 CONFIG_PACKET=y
 # CONFIG_PACKET_MMAP is not set
 CONFIG_UNIX=y
-# CONFIG_NET_KEY is not set
+CONFIG_XFRM=y
+CONFIG_XFRM_USER=y
+CONFIG_NET_KEY=y
 CONFIG_INET=y
 CONFIG_IP_MULTICAST=y
 # CONFIG_IP_ADVANCED_ROUTER is not set
@@ -250,9 +251,10 @@ CONFIG_IP_FIB_HASH=y
 # 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_AH=y
+CONFIG_INET_ESP=y
 # CONFIG_INET_IPCOMP is not set
+# CONFIG_INET_XFRM_TUNNEL is not set
 # CONFIG_INET_TUNNEL is not set
 CONFIG_INET_DIAG=y
 CONFIG_INET_TCP_DIAG=y
@@ -264,6 +266,8 @@ CONFIG_TCP_CONG_BIC=y
 #
 # CONFIG_IP_VS is not set
 # CONFIG_IPV6 is not set
+# CONFIG_INET6_XFRM_TUNNEL is not set
+# CONFIG_INET6_TUNNEL is not set
 CONFIG_NETFILTER=y
 # CONFIG_NETFILTER_DEBUG is not set
 
@@ -278,12 +282,15 @@ CONFIG_NETFILTER_XT_TARGET_NFQUEUE=m
 CONFIG_NETFILTER_XT_TARGET_NOTRACK=m
 CONFIG_NETFILTER_XT_MATCH_COMMENT=m
 CONFIG_NETFILTER_XT_MATCH_CONNTRACK=m
-# CONFIG_NETFILTER_XT_MATCH_DCCP is not set
+CONFIG_NETFILTER_XT_MATCH_DCCP=m
+CONFIG_NETFILTER_XT_MATCH_ESP=m
 CONFIG_NETFILTER_XT_MATCH_HELPER=m
 CONFIG_NETFILTER_XT_MATCH_LENGTH=m
 CONFIG_NETFILTER_XT_MATCH_LIMIT=m
 CONFIG_NETFILTER_XT_MATCH_MAC=m
 CONFIG_NETFILTER_XT_MATCH_MARK=m
+CONFIG_NETFILTER_XT_MATCH_POLICY=m
+CONFIG_NETFILTER_XT_MATCH_MULTIPORT=m
 CONFIG_NETFILTER_XT_MATCH_PKTTYPE=m
 CONFIG_NETFILTER_XT_MATCH_REALM=m
 CONFIG_NETFILTER_XT_MATCH_SCTP=m
@@ -305,15 +312,15 @@ CONFIG_IP_NF_NETBIOS_NS=m
 CONFIG_IP_NF_TFTP=m
 CONFIG_IP_NF_AMANDA=m
 CONFIG_IP_NF_PPTP=m
+CONFIG_IP_NF_H323=m
 # CONFIG_IP_NF_QUEUE is not set
 CONFIG_IP_NF_IPTABLES=m
 CONFIG_IP_NF_MATCH_IPRANGE=m
-CONFIG_IP_NF_MATCH_MULTIPORT=m
 CONFIG_IP_NF_MATCH_TOS=m
 CONFIG_IP_NF_MATCH_RECENT=m
 CONFIG_IP_NF_MATCH_ECN=m
 CONFIG_IP_NF_MATCH_DSCP=m
-CONFIG_IP_NF_MATCH_AH_ESP=m
+CONFIG_IP_NF_MATCH_AH=m
 CONFIG_IP_NF_MATCH_TTL=m
 CONFIG_IP_NF_MATCH_OWNER=m
 CONFIG_IP_NF_MATCH_ADDRTYPE=m
@@ -335,6 +342,7 @@ CONFIG_IP_NF_NAT_FTP=m
 CONFIG_IP_NF_NAT_TFTP=m
 CONFIG_IP_NF_NAT_AMANDA=m
 CONFIG_IP_NF_NAT_PPTP=m
+CONFIG_IP_NF_NAT_H323=m
 CONFIG_IP_NF_MANGLE=m
 CONFIG_IP_NF_TARGET_TOS=m
 CONFIG_IP_NF_TARGET_ECN=m
@@ -350,10 +358,12 @@ CONFIG_IP_NF_ARP_MANGLE=m
 #
 CONFIG_IP_DCCP=m
 CONFIG_INET_DCCP_DIAG=m
+CONFIG_IP_DCCP_ACKVEC=y
 
 #
 # DCCP CCIDs Configuration (EXPERIMENTAL)
 #
+CONFIG_IP_DCCP_CCID2=m
 CONFIG_IP_DCCP_CCID3=m
 CONFIG_IP_DCCP_TFRC_LIB=m
 
@@ -361,7 +371,6 @@ CONFIG_IP_DCCP_TFRC_LIB=m
 # DCCP Kernel Hacking
 #
 # CONFIG_IP_DCCP_DEBUG is not set
-# CONFIG_IP_DCCP_UNLOAD_HACK is not set
 
 #
 # SCTP Configuration (EXPERIMENTAL)
@@ -477,6 +486,8 @@ CONFIG_IEEE80211=m
 CONFIG_IEEE80211_CRYPT_WEP=m
 CONFIG_IEEE80211_CRYPT_CCMP=m
 CONFIG_IEEE80211_CRYPT_TKIP=m
+# CONFIG_IEEE80211_SOFTMAC is not set
+CONFIG_WIRELESS_EXT=y
 
 #
 # Device Drivers
@@ -662,9 +673,8 @@ CONFIG_SCSI_SYM53C8XX_2=y
 CONFIG_SCSI_SYM53C8XX_DMA_ADDRESSING_MODE=0
 CONFIG_SCSI_SYM53C8XX_DEFAULT_TAGS=16
 CONFIG_SCSI_SYM53C8XX_MAX_TAGS=64
-# CONFIG_SCSI_SYM53C8XX_IOMAPPED is not set
+CONFIG_SCSI_SYM53C8XX_MMIO=y
 # CONFIG_SCSI_IPR is not set
-# CONFIG_SCSI_QLOGIC_FC is not set
 # CONFIG_SCSI_QLOGIC_1280 is not set
 # CONFIG_SCSI_QLA_FC is not set
 # CONFIG_SCSI_LPFC is not set
@@ -694,16 +704,17 @@ CONFIG_BLK_DEV_MD=m
 CONFIG_MD_LINEAR=m
 CONFIG_MD_RAID0=m
 CONFIG_MD_RAID1=m
-# CONFIG_MD_RAID10 is not set
+CONFIG_MD_RAID10=m
 CONFIG_MD_RAID5=m
+CONFIG_MD_RAID5_RESHAPE=y
 CONFIG_MD_RAID6=m
 CONFIG_MD_MULTIPATH=m
 CONFIG_MD_FAULTY=m
 CONFIG_BLK_DEV_DM=m
 CONFIG_DM_CRYPT=m
-# CONFIG_DM_SNAPSHOT is not set
-# CONFIG_DM_MIRROR is not set
-# CONFIG_DM_ZERO is not set
+CONFIG_DM_SNAPSHOT=m
+CONFIG_DM_MIRROR=m
+CONFIG_DM_ZERO=m
 # CONFIG_DM_MULTIPATH is not set
 
 #
@@ -740,7 +751,7 @@ CONFIG_IEEE1394_OHCI1394=m
 CONFIG_IEEE1394_VIDEO1394=m
 CONFIG_IEEE1394_SBP2=m
 # CONFIG_IEEE1394_SBP2_PHYS_DMA is not set
-CONFIG_IEEE1394_ETH1394=m
+# CONFIG_IEEE1394_ETH1394 is not set
 CONFIG_IEEE1394_DV1394=m
 CONFIG_IEEE1394_RAWIO=m
 
@@ -769,10 +780,10 @@ CONFIG_THERM_ADT746X=m
 # Network device support
 #
 CONFIG_NETDEVICES=y
-# CONFIG_DUMMY is not set
+CONFIG_DUMMY=m
 # CONFIG_BONDING is not set
 # CONFIG_EQUALIZER is not set
-# CONFIG_TUN is not set
+CONFIG_TUN=m
 
 #
 # ARCnet devices
@@ -857,6 +868,7 @@ CONFIG_PCNET32=y
 # Wireless LAN (non-hamradio)
 #
 CONFIG_NET_RADIO=y
+# CONFIG_NET_WIRELESS_RTNETLINK is not set
 
 #
 # Obsolete Wireless cards support (pre-802.11)
@@ -992,6 +1004,7 @@ CONFIG_HW_CONSOLE=y
 # Serial drivers
 #
 CONFIG_SERIAL_8250=m
+CONFIG_SERIAL_8250_PCI=m
 # CONFIG_SERIAL_8250_CS is not set
 CONFIG_SERIAL_8250_NR_UARTS=4
 CONFIG_SERIAL_8250_RUNTIME_UARTS=4
@@ -1027,6 +1040,7 @@ CONFIG_GEN_RTC=y
 # Ftape, the floppy tape device driver
 #
 CONFIG_AGP=m
+# CONFIG_AGP_VIA is not set
 CONFIG_AGP_UNINORTH=m
 CONFIG_DRM=m
 # CONFIG_DRM_TDFX is not set
@@ -1081,7 +1095,6 @@ CONFIG_I2C_POWERMAC=y
 # 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
@@ -1100,10 +1113,8 @@ CONFIG_I2C_POWERMAC=y
 # 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
@@ -1131,18 +1142,16 @@ CONFIG_I2C_POWERMAC=y
 #
 
 #
-# Multimedia Capabilities Port drivers
-#
-
-#
 # Multimedia devices
 #
 # CONFIG_VIDEO_DEV is not set
+CONFIG_VIDEO_V4L2=y
 
 #
 # Digital Video Broadcasting Devices
 #
 # CONFIG_DVB is not set
+# CONFIG_USB_DABUSB is not set
 
 #
 # Graphics support
@@ -1152,6 +1161,7 @@ CONFIG_FB_CFB_FILLRECT=y
 CONFIG_FB_CFB_COPYAREA=y
 CONFIG_FB_CFB_IMAGEBLIT=y
 CONFIG_FB_MACMODES=y
+CONFIG_FB_FIRMWARE_EDID=y
 CONFIG_FB_MODE_HELPERS=y
 CONFIG_FB_TILEBLITTING=y
 # CONFIG_FB_CIRRUS is not set
@@ -1175,7 +1185,6 @@ CONFIG_FB_MATROX_MYSTIQUE=y
 # CONFIG_FB_MATROX_G is not set
 # CONFIG_FB_MATROX_I2C is not set
 # CONFIG_FB_MATROX_MULTIHEAD is not set
-# CONFIG_FB_RADEON_OLD is not set
 CONFIG_FB_RADEON=y
 CONFIG_FB_RADEON_I2C=y
 # CONFIG_FB_RADEON_DEBUG is not set
@@ -1234,9 +1243,11 @@ CONFIG_SND_SEQ_DUMMY=m
 CONFIG_SND_OSSEMUL=y
 CONFIG_SND_MIXER_OSS=m
 CONFIG_SND_PCM_OSS=m
+CONFIG_SND_PCM_OSS_PLUGINS=y
 CONFIG_SND_SEQUENCER_OSS=y
 # CONFIG_SND_DYNAMIC_MINORS is not set
 CONFIG_SND_SUPPORT_OLD_API=y
+CONFIG_SND_VERBOSE_PROCFS=y
 # CONFIG_SND_VERBOSE_PRINTK is not set
 # CONFIG_SND_DEBUG is not set
 
@@ -1253,6 +1264,7 @@ CONFIG_SND_DUMMY=m
 # PCI devices
 #
 # CONFIG_SND_AD1889 is not set
+# CONFIG_SND_ALS300 is not set
 # CONFIG_SND_ALS4000 is not set
 # CONFIG_SND_ALI5451 is not set
 # CONFIG_SND_ATIIXP is not set
@@ -1285,6 +1297,7 @@ CONFIG_SND_DUMMY=m
 # CONFIG_SND_MIXART is not set
 # CONFIG_SND_NM256 is not set
 # CONFIG_SND_PCXHR is not set
+# CONFIG_SND_RIPTIDE is not set
 # CONFIG_SND_RME32 is not set
 # CONFIG_SND_RME96 is not set
 # CONFIG_SND_RME9652 is not set
@@ -1310,6 +1323,8 @@ CONFIG_SND_USB_AUDIO=m
 #
 # PCMCIA devices
 #
+# CONFIG_SND_VXPOCKET is not set
+# CONFIG_SND_PDAUDIOCF is not set
 
 #
 # Open Sound System
@@ -1321,6 +1336,7 @@ CONFIG_SND_USB_AUDIO=m
 #
 CONFIG_USB_ARCH_HAS_HCD=y
 CONFIG_USB_ARCH_HAS_OHCI=y
+CONFIG_USB_ARCH_HAS_EHCI=y
 CONFIG_USB=y
 # CONFIG_USB_DEBUG is not set
 
@@ -1336,7 +1352,9 @@ CONFIG_USB_DYNAMIC_MINORS=y
 #
 # USB Host Controller Drivers
 #
-# CONFIG_USB_EHCI_HCD is not set
+CONFIG_USB_EHCI_HCD=m
+CONFIG_USB_EHCI_SPLIT_ISO=y
+CONFIG_USB_EHCI_ROOT_HUB_TT=y
 # CONFIG_USB_ISP116X_HCD is not set
 CONFIG_USB_OHCI_HCD=y
 # CONFIG_USB_OHCI_BIG_ENDIAN is not set
@@ -1347,7 +1365,6 @@ CONFIG_USB_OHCI_LITTLE_ENDIAN=y
 #
 # USB Device Class drivers
 #
-# CONFIG_OBSOLETE_OSS_USB_DRIVER is not set
 CONFIG_USB_ACM=m
 CONFIG_USB_PRINTER=m
 
@@ -1358,7 +1375,17 @@ CONFIG_USB_PRINTER=m
 #
 # may also be needed; see USB_STORAGE Help for more information
 #
-# CONFIG_USB_STORAGE is not set
+CONFIG_USB_STORAGE=m
+# CONFIG_USB_STORAGE_DEBUG is not set
+# CONFIG_USB_STORAGE_DATAFAB is not set
+# CONFIG_USB_STORAGE_FREECOM is not set
+# CONFIG_USB_STORAGE_ISD200 is not set
+# CONFIG_USB_STORAGE_DPCM is not set
+# CONFIG_USB_STORAGE_USBAT is not set
+# CONFIG_USB_STORAGE_SDDR09 is not set
+# CONFIG_USB_STORAGE_SDDR55 is not set
+# CONFIG_USB_STORAGE_JUMPSHOT is not set
+# CONFIG_USB_STORAGE_ALAUDA is not set
 # CONFIG_USB_LIBUSUAL is not set
 
 #
@@ -1374,9 +1401,7 @@ CONFIG_USB_HIDINPUT_POWERBOOK=y
 # CONFIG_USB_ACECAD is not set
 # CONFIG_USB_KBTAB is not set
 # CONFIG_USB_POWERMATE is not set
-# CONFIG_USB_MTOUCH is not set
-# CONFIG_USB_ITMTOUCH is not set
-# CONFIG_USB_EGALAX is not set
+# CONFIG_USB_TOUCHSCREEN is not set
 # CONFIG_USB_YEALINK is not set
 # CONFIG_USB_XPAD is not set
 # CONFIG_USB_ATI_REMOTE is not set
@@ -1391,15 +1416,6 @@ CONFIG_USB_APPLETOUCH=y
 # CONFIG_USB_MICROTEK is not set
 
 #
-# USB Multimedia devices
-#
-# CONFIG_USB_DABUSB is not set
-
-#
-# Video4Linux support is needed for USB Multimedia device support
-#
-
-#
 # USB Network Adapters
 #
 # CONFIG_USB_CATC is not set
@@ -1429,6 +1445,7 @@ CONFIG_USB_SERIAL=m
 # CONFIG_USB_SERIAL_GENERIC is not set
 # CONFIG_USB_SERIAL_AIRPRIME is not set
 # CONFIG_USB_SERIAL_ANYDATA is not set
+# CONFIG_USB_SERIAL_ARK3116 is not set
 # CONFIG_USB_SERIAL_BELKIN is not set
 # CONFIG_USB_SERIAL_WHITEHEAT is not set
 # CONFIG_USB_SERIAL_DIGI_ACCELEPORT is not set
@@ -1436,6 +1453,7 @@ CONFIG_USB_SERIAL=m
 # CONFIG_USB_SERIAL_CYPRESS_M8 is not set
 # CONFIG_USB_SERIAL_EMPEG is not set
 # CONFIG_USB_SERIAL_FTDI_SIO is not set
+# CONFIG_USB_SERIAL_FUNSOFT is not set
 CONFIG_USB_SERIAL_VISOR=m
 CONFIG_USB_SERIAL_IPAQ=m
 # CONFIG_USB_SERIAL_IR is not set
@@ -1460,6 +1478,7 @@ CONFIG_USB_SERIAL_KEYSPAN_USA49WLC=y
 # CONFIG_USB_SERIAL_KLSI is not set
 # CONFIG_USB_SERIAL_KOBIL_SCT is not set
 # CONFIG_USB_SERIAL_MCT_U232 is not set
+# CONFIG_USB_SERIAL_NAVMAN is not set
 # CONFIG_USB_SERIAL_PL2303 is not set
 # CONFIG_USB_SERIAL_HP4X is not set
 # CONFIG_USB_SERIAL_SAFE is not set
@@ -1484,6 +1503,7 @@ CONFIG_USB_EZUSB=y
 # CONFIG_USB_PHIDGETKIT is not set
 # CONFIG_USB_PHIDGETSERVO is not set
 # CONFIG_USB_IDMOUSE is not set
+# CONFIG_USB_SISUSBVGA is not set
 # CONFIG_USB_LD is not set
 # CONFIG_USB_TEST is not set
 
@@ -1502,6 +1522,19 @@ CONFIG_USB_EZUSB=y
 # CONFIG_MMC is not set
 
 #
+# LED devices
+#
+# CONFIG_NEW_LEDS is not set
+
+#
+# LED drivers
+#
+
+#
+# LED Triggers
+#
+
+#
 # InfiniBand support
 #
 # CONFIG_INFINIBAND is not set
@@ -1511,6 +1544,11 @@ CONFIG_USB_EZUSB=y
 #
 
 #
+# Real Time Clock
+#
+# CONFIG_RTC_CLASS is not set
+
+#
 # File systems
 #
 CONFIG_EXT2_FS=y
@@ -1518,14 +1556,14 @@ CONFIG_EXT2_FS=y
 # 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_POSIX_ACL=y
 # 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_FS_POSIX_ACL=y
 # CONFIG_XFS_FS is not set
 # CONFIG_OCFS2_FS is not set
 # CONFIG_MINIX_FS is not set
@@ -1534,7 +1572,7 @@ CONFIG_INOTIFY=y
 # CONFIG_QUOTA is not set
 CONFIG_DNOTIFY=y
 # CONFIG_AUTOFS_FS is not set
-# CONFIG_AUTOFS4_FS is not set
+CONFIG_AUTOFS4_FS=m
 CONFIG_FUSE_FS=m
 
 #
@@ -1566,7 +1604,6 @@ CONFIG_SYSFS=y
 CONFIG_TMPFS=y
 # CONFIG_HUGETLB_PAGE is not set
 CONFIG_RAMFS=y
-CONFIG_RELAYFS_FS=m
 # CONFIG_CONFIGFS_FS is not set
 
 #
@@ -1590,17 +1627,24 @@ CONFIG_HFSPLUS_FS=m
 # Network File Systems
 #
 CONFIG_NFS_FS=y
-# CONFIG_NFS_V3 is not set
-# CONFIG_NFS_V4 is not set
+CONFIG_NFS_V3=y
+CONFIG_NFS_V3_ACL=y
+CONFIG_NFS_V4=y
 # CONFIG_NFS_DIRECTIO is not set
-CONFIG_NFSD=y
-# CONFIG_NFSD_V3 is not set
-# CONFIG_NFSD_TCP is not set
+CONFIG_NFSD=m
+CONFIG_NFSD_V2_ACL=y
+CONFIG_NFSD_V3=y
+CONFIG_NFSD_V3_ACL=y
+CONFIG_NFSD_V4=y
+CONFIG_NFSD_TCP=y
 CONFIG_LOCKD=y
-CONFIG_EXPORTFS=y
+CONFIG_LOCKD_V4=y
+CONFIG_EXPORTFS=m
+CONFIG_NFS_ACL_SUPPORT=y
 CONFIG_NFS_COMMON=y
 CONFIG_SUNRPC=y
-# CONFIG_RPCSEC_GSS_KRB5 is not set
+CONFIG_SUNRPC_GSS=y
+CONFIG_RPCSEC_GSS_KRB5=y
 # CONFIG_RPCSEC_GSS_SPKM3 is not set
 CONFIG_SMB_FS=m
 # CONFIG_SMB_NLS_DEFAULT is not set
@@ -1681,7 +1725,7 @@ CONFIG_NLS_UTF8=m
 CONFIG_CRC_CCITT=y
 CONFIG_CRC16=y
 CONFIG_CRC32=y
-# CONFIG_LIBCRC32C is not set
+CONFIG_LIBCRC32C=m
 CONFIG_ZLIB_INFLATE=y
 CONFIG_ZLIB_DEFLATE=y
 CONFIG_TEXTSEARCH=y
@@ -1735,29 +1779,29 @@ CONFIG_BOOTX_TEXT=y
 # 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 is not set
-# 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 is not set
-# CONFIG_CRYPTO_BLOWFISH is not set
-# CONFIG_CRYPTO_TWOFISH is not set
-# CONFIG_CRYPTO_SERPENT is not set
+CONFIG_CRYPTO_HMAC=y
+CONFIG_CRYPTO_NULL=m
+CONFIG_CRYPTO_MD4=m
+CONFIG_CRYPTO_MD5=y
+CONFIG_CRYPTO_SHA1=y
+CONFIG_CRYPTO_SHA256=m
+CONFIG_CRYPTO_SHA512=m
+CONFIG_CRYPTO_WP512=m
+CONFIG_CRYPTO_TGR192=m
+CONFIG_CRYPTO_DES=y
+CONFIG_CRYPTO_BLOWFISH=m
+CONFIG_CRYPTO_TWOFISH=m
+CONFIG_CRYPTO_SERPENT=m
 CONFIG_CRYPTO_AES=m
-# CONFIG_CRYPTO_CAST5 is not set
-# CONFIG_CRYPTO_CAST6 is not set
-# CONFIG_CRYPTO_TEA is not set
+CONFIG_CRYPTO_CAST5=m
+CONFIG_CRYPTO_CAST6=m
+CONFIG_CRYPTO_TEA=m
 CONFIG_CRYPTO_ARC4=m
-# CONFIG_CRYPTO_KHAZAD is not set
-# CONFIG_CRYPTO_ANUBIS is not set
-# CONFIG_CRYPTO_DEFLATE is not set
+CONFIG_CRYPTO_KHAZAD=m
+CONFIG_CRYPTO_ANUBIS=m
+CONFIG_CRYPTO_DEFLATE=m
 CONFIG_CRYPTO_MICHAEL_MIC=m
-# CONFIG_CRYPTO_CRC32C is not set
+CONFIG_CRYPTO_CRC32C=m
 # CONFIG_CRYPTO_TEST is not set
 
 #
diff --git a/arch/powerpc/configs/pseries_defconfig b/arch/powerpc/configs/pseries_defconfig
index 58e68ce09b0f..31708ad4574e 100644
--- a/arch/powerpc/configs/pseries_defconfig
+++ b/arch/powerpc/configs/pseries_defconfig
@@ -1,7 +1,7 @@
 #
 # Automatically generated make config: don't edit
-# Linux kernel version: 2.6.17-rc1
-# Wed Apr 19 11:48:00 2006
+# Linux kernel version: 2.6.17-rc4
+# Sun May 28 07:26:56 2006
 #
 CONFIG_PPC64=y
 CONFIG_64BIT=y
@@ -11,6 +11,7 @@ CONFIG_GENERIC_HARDIRQS=y
 CONFIG_RWSEM_XCHGADD_ALGORITHM=y
 CONFIG_GENERIC_HWEIGHT=y
 CONFIG_GENERIC_CALIBRATE_DELAY=y
+CONFIG_GENERIC_FIND_NEXT_BIT=y
 CONFIG_PPC=y
 CONFIG_EARLY_PRINTK=y
 CONFIG_COMPAT=y
@@ -126,8 +127,9 @@ CONFIG_RTAS_PROC=y
 CONFIG_RTAS_FLASH=m
 # CONFIG_MMIO_NVRAM is not set
 CONFIG_IBMVIO=y
-# CONFIG_IBMEBUS is not set
+CONFIG_IBMEBUS=y
 # CONFIG_PPC_MPC106 is not set
+# CONFIG_PPC_970_NAP is not set
 # CONFIG_CPU_FREQ is not set
 # CONFIG_WANT_EARLY_SERIAL is not set
 
@@ -143,7 +145,7 @@ CONFIG_PREEMPT_NONE=y
 # CONFIG_PREEMPT is not set
 # CONFIG_PREEMPT_BKL is not set
 CONFIG_BINFMT_ELF=y
-# CONFIG_BINFMT_MISC is not set
+CONFIG_BINFMT_MISC=m
 CONFIG_FORCE_MAX_ZONEORDER=13
 CONFIG_IOMMU_VMERGE=y
 CONFIG_HOTPLUG_CPU=y
@@ -155,6 +157,7 @@ CONFIG_EEH=y
 CONFIG_SCANLOG=m
 CONFIG_LPARCFG=y
 CONFIG_NUMA=y
+CONFIG_NODES_SHIFT=4
 CONFIG_ARCH_SELECT_MEMORY_MODEL=y
 CONFIG_ARCH_SPARSEMEM_ENABLE=y
 CONFIG_ARCH_SPARSEMEM_DEFAULT=y
@@ -467,7 +470,7 @@ CONFIG_SCSI_CONSTANTS=y
 CONFIG_SCSI_SPI_ATTRS=y
 CONFIG_SCSI_FC_ATTRS=y
 CONFIG_SCSI_ISCSI_ATTRS=m
-# CONFIG_SCSI_SAS_ATTRS is not set
+CONFIG_SCSI_SAS_ATTRS=m
 
 #
 # SCSI low-level drivers
@@ -499,13 +502,18 @@ CONFIG_SCSI_SYM53C8XX_2=y
 CONFIG_SCSI_SYM53C8XX_DMA_ADDRESSING_MODE=0
 CONFIG_SCSI_SYM53C8XX_DEFAULT_TAGS=16
 CONFIG_SCSI_SYM53C8XX_MAX_TAGS=64
-# CONFIG_SCSI_SYM53C8XX_IOMAPPED is not set
+CONFIG_SCSI_SYM53C8XX_MMIO=y
 CONFIG_SCSI_IPR=y
 CONFIG_SCSI_IPR_TRACE=y
 CONFIG_SCSI_IPR_DUMP=y
-# CONFIG_SCSI_QLOGIC_FC is not set
 # CONFIG_SCSI_QLOGIC_1280 is not set
-# CONFIG_SCSI_QLA_FC is not set
+CONFIG_SCSI_QLA_FC=m
+CONFIG_SCSI_QLA2XXX_EMBEDDED_FIRMWARE=y
+CONFIG_SCSI_QLA21XX=m
+CONFIG_SCSI_QLA22XX=m
+CONFIG_SCSI_QLA2300=m
+CONFIG_SCSI_QLA2322=m
+CONFIG_SCSI_QLA24XX=m
 CONFIG_SCSI_LPFC=m
 # CONFIG_SCSI_DC395x is not set
 # CONFIG_SCSI_DC390T is not set
@@ -521,7 +529,7 @@ CONFIG_MD_RAID0=y
 CONFIG_MD_RAID1=y
 CONFIG_MD_RAID10=m
 CONFIG_MD_RAID5=y
-# CONFIG_MD_RAID5_RESHAPE is not set
+CONFIG_MD_RAID5_RESHAPE=y
 CONFIG_MD_RAID6=m
 CONFIG_MD_MULTIPATH=m
 CONFIG_MD_FAULTY=m
@@ -764,7 +772,7 @@ CONFIG_SERIAL_8250_RUNTIME_UARTS=4
 CONFIG_SERIAL_CORE=y
 CONFIG_SERIAL_CORE_CONSOLE=y
 CONFIG_SERIAL_ICOM=m
-# CONFIG_SERIAL_JSM is not set
+CONFIG_SERIAL_JSM=m
 CONFIG_UNIX98_PTYS=y
 CONFIG_LEGACY_PTYS=y
 CONFIG_LEGACY_PTY_COUNT=256
@@ -773,7 +781,7 @@ CONFIG_LEGACY_PTY_COUNT=256
 # CONFIG_TIPAR is not set
 CONFIG_HVC_DRIVER=y
 CONFIG_HVC_CONSOLE=y
-# CONFIG_HVC_RTAS is not set
+CONFIG_HVC_RTAS=y
 CONFIG_HVCS=m
 
 #
@@ -1031,9 +1039,7 @@ CONFIG_USB_HIDDEV=y
 # CONFIG_USB_ACECAD is not set
 # CONFIG_USB_KBTAB is not set
 # CONFIG_USB_POWERMATE is not set
-# CONFIG_USB_MTOUCH is not set
-# CONFIG_USB_ITMTOUCH is not set
-# CONFIG_USB_EGALAX is not set
+# CONFIG_USB_TOUCHSCREEN is not set
 # CONFIG_USB_YEALINK is not set
 # CONFIG_USB_XPAD is not set
 # CONFIG_USB_ATI_REMOTE is not set
@@ -1105,16 +1111,25 @@ CONFIG_USB_MON=y
 # CONFIG_NEW_LEDS is not set
 
 #
+# LED drivers
+#
+
+#
+# LED Triggers
+#
+
+#
 # InfiniBand support
 #
 CONFIG_INFINIBAND=m
-# CONFIG_INFINIBAND_USER_MAD is not set
-# CONFIG_INFINIBAND_USER_ACCESS is not set
+CONFIG_INFINIBAND_USER_MAD=m
+CONFIG_INFINIBAND_USER_ACCESS=m
 CONFIG_INFINIBAND_MTHCA=m
-# CONFIG_INFINIBAND_MTHCA_DEBUG is not set
+CONFIG_INFINIBAND_MTHCA_DEBUG=y
 CONFIG_INFINIBAND_IPOIB=m
-# CONFIG_INFINIBAND_IPOIB_DEBUG is not set
-# CONFIG_INFINIBAND_SRP is not set
+CONFIG_INFINIBAND_IPOIB_DEBUG=y
+# CONFIG_INFINIBAND_IPOIB_DEBUG_DATA is not set
+CONFIG_INFINIBAND_SRP=m
 
 #
 # EDAC - error detection and reporting (RAS) (EXPERIMENTAL)
@@ -1159,15 +1174,15 @@ CONFIG_XFS_EXPORT=y
 CONFIG_XFS_SECURITY=y
 CONFIG_XFS_POSIX_ACL=y
 # CONFIG_XFS_RT is not set
-# CONFIG_OCFS2_FS is not set
+CONFIG_OCFS2_FS=m
 # 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=m
-# CONFIG_AUTOFS4_FS is not set
-# CONFIG_FUSE_FS is not set
+# CONFIG_AUTOFS_FS is not set
+CONFIG_AUTOFS4_FS=m
+CONFIG_FUSE_FS=m
 
 #
 # CD-ROM/DVD Filesystems
@@ -1199,7 +1214,7 @@ CONFIG_TMPFS=y
 CONFIG_HUGETLBFS=y
 CONFIG_HUGETLB_PAGE=y
 CONFIG_RAMFS=y
-# CONFIG_CONFIGFS_FS is not set
+CONFIG_CONFIGFS_FS=m
 
 #
 # Miscellaneous filesystems
@@ -1317,7 +1332,7 @@ CONFIG_ZLIB_DEFLATE=m
 #
 CONFIG_PROFILING=y
 CONFIG_OPROFILE=y
-# CONFIG_KPROBES is not set
+CONFIG_KPROBES=y
 
 #
 # Kernel hacking
@@ -1329,7 +1344,7 @@ CONFIG_LOG_BUF_SHIFT=17
 CONFIG_DETECT_SOFTLOCKUP=y
 # CONFIG_SCHEDSTATS is not set
 # CONFIG_DEBUG_SLAB is not set
-CONFIG_DEBUG_MUTEXES=y
+# 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
@@ -1339,17 +1354,13 @@ CONFIG_DEBUG_FS=y
 CONFIG_FORCED_INLINING=y
 # CONFIG_RCU_TORTURE_TEST is not set
 CONFIG_DEBUG_STACKOVERFLOW=y
-CONFIG_DEBUG_STACK_USAGE=y
+# CONFIG_DEBUG_STACK_USAGE is not set
 CONFIG_DEBUGGER=y
 CONFIG_XMON=y
 CONFIG_XMON_DEFAULT=y
 CONFIG_IRQSTACKS=y
 # CONFIG_BOOTX_TEXT 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
+# CONFIG_PPC_EARLY_DEBUG is not set
 
 #
 # Security options
diff --git a/arch/powerpc/kernel/align.c b/arch/powerpc/kernel/align.c
index faaec9c6f78f..4734b5de599d 100644
--- a/arch/powerpc/kernel/align.c
+++ b/arch/powerpc/kernel/align.c
@@ -35,17 +35,19 @@ struct aligninfo {
 
 #define INVALID { 0, 0 }
 
-#define LD      1       /* load */
-#define ST      2       /* store */
-#define SE      4       /* sign-extend value */
-#define F       8       /* to/from fp regs */
-#define U       0x10    /* update index register */
-#define M       0x20    /* multiple load/store */
-#define SW      0x40    /* byte swap int or ... */
-#define S       0x40    /* ... single-precision fp */
-#define SX      0x40    /* byte count in XER */
+/* Bits in the flags field */
+#define LD      0       /* load */
+#define ST      1       /* store */
+#define SE      2       /* sign-extend value */
+#define F       4       /* to/from fp regs */
+#define U       8       /* update index register */
+#define M       0x10    /* multiple load/store */
+#define SW      0x20    /* byte swap */
+#define S       0x40    /* single-precision fp or... */
+#define SX      0x40    /* ... byte count in XER */
 #define HARD    0x80    /* string, stwcx. */
 
+/* DSISR bits reported for a DCBZ instruction: */
 #define DCBZ    0x5f    /* 8xx/82xx dcbz faults when cache not enabled */
 
 #define SWAP(a, b)      (t = (a), (a) = (b), (b) = t)
@@ -256,12 +258,16 @@ static int emulate_dcbz(struct pt_regs *regs, unsigned char __user *addr)
 #define REG_BYTE(rp, i)         *((u8 *)(rp) + (i))
 #endif
 
+#define SWIZ_PTR(p)             ((unsigned char __user *)((p) ^ swiz))
+
 static int emulate_multiple(struct pt_regs *regs, unsigned char __user *addr,
                             unsigned int reg, unsigned int nb,
-                            unsigned int flags, unsigned int instr)
+                            unsigned int flags, unsigned int instr,
+                            unsigned long swiz)
 {
         unsigned long *rptr;
-        unsigned int nb0, i;
+        unsigned int nb0, i, bswiz;
+        unsigned long p;
 
         /*
          * We do not try to emulate 8 bytes multiple as they aren't really
@@ -280,9 +286,12 @@ static int emulate_multiple(struct pt_regs *regs, unsigned char __user *addr,
                         if (nb == 0)
                                 return 1;
                 } else {
-                        if (__get_user(instr,
-                                       (unsigned int __user *)regs->nip))
+                        unsigned long pc = regs->nip ^ (swiz & 4);
+
+                        if (__get_user(instr, (unsigned int __user *)pc))
                                 return -EFAULT;
+                        if (swiz == 0 && (flags & SW))
+                                instr = cpu_to_le32(instr);
                         nb = (instr >> 11) & 0x1f;
                         if (nb == 0)
                                 nb = 32;
@@ -300,7 +309,10 @@ static int emulate_multiple(struct pt_regs *regs, unsigned char __user *addr,
                 return -EFAULT; /* bad address */
 
         rptr = &regs->gpr[reg];
-        if (flags & LD) {
+        p = (unsigned long) addr;
+        bswiz = (flags & SW)? 3: 0;
+
+        if (!(flags & ST)) {
                 /*
                  * This zeroes the top 4 bytes of the affected registers
                  * in 64-bit mode, and also zeroes out any remaining
@@ -311,26 +323,28 @@ static int emulate_multiple(struct pt_regs *regs, unsigned char __user *addr,
                         memset(&regs->gpr[0], 0,
                                ((nb0 + 3) / 4) * sizeof(unsigned long));
 
-                for (i = 0; i < nb; ++i)
-                        if (__get_user(REG_BYTE(rptr, i), addr + i))
+                for (i = 0; i < nb; ++i, ++p)
+                        if (__get_user(REG_BYTE(rptr, i ^ bswiz), SWIZ_PTR(p)))
                                 return -EFAULT;
                 if (nb0 > 0) {
                         rptr = &regs->gpr[0];
                         addr += nb;
-                        for (i = 0; i < nb0; ++i)
-                                if (__get_user(REG_BYTE(rptr, i), addr + i))
+                        for (i = 0; i < nb0; ++i, ++p)
+                                if (__get_user(REG_BYTE(rptr, i ^ bswiz),
+                                               SWIZ_PTR(p)))
                                         return -EFAULT;
                 }
 
         } else {
-                for (i = 0; i < nb; ++i)
-                        if (__put_user(REG_BYTE(rptr, i), addr + i))
+                for (i = 0; i < nb; ++i, ++p)
+                        if (__put_user(REG_BYTE(rptr, i ^ bswiz), SWIZ_PTR(p)))
                                 return -EFAULT;
                 if (nb0 > 0) {
                         rptr = &regs->gpr[0];
                         addr += nb;
-                        for (i = 0; i < nb0; ++i)
-                                if (__put_user(REG_BYTE(rptr, i), addr + i))
+                        for (i = 0; i < nb0; ++i, ++p)
+                                if (__put_user(REG_BYTE(rptr, i ^ bswiz),
+                                               SWIZ_PTR(p)))
                                         return -EFAULT;
                 }
         }
@@ -352,7 +366,7 @@ int fix_alignment(struct pt_regs *regs)
         unsigned int reg, areg;
         unsigned int dsisr;
         unsigned char __user *addr;
-        unsigned char __user *p;
+        unsigned long p, swiz;
         int ret, t;
         union {
                 u64 ll;
@@ -380,11 +394,15 @@ int fix_alignment(struct pt_regs *regs)
          * let's make one up from the instruction
          */
         if (cpu_has_feature(CPU_FTR_NODSISRALIGN)) {
-                unsigned int real_instr;
-                if (unlikely(__get_user(real_instr,
-                                        (unsigned int __user *)regs->nip)))
+                unsigned long pc = regs->nip;
+
+                if (cpu_has_feature(CPU_FTR_PPC_LE) && (regs->msr & MSR_LE))
+                        pc ^= 4;
+                if (unlikely(__get_user(instr, (unsigned int __user *)pc)))
                         return -EFAULT;
-                dsisr = make_dsisr(real_instr);
+                if (cpu_has_feature(CPU_FTR_REAL_LE) && (regs->msr & MSR_LE))
+                        instr = cpu_to_le32(instr);
+                dsisr = make_dsisr(instr);
         }
 
         /* extract the operation and registers from the dsisr */
@@ -397,6 +415,24 @@ int fix_alignment(struct pt_regs *regs)
         nb = aligninfo[instr].len;
         flags = aligninfo[instr].flags;
 
+        /* Byteswap little endian loads and stores */
+        swiz = 0;
+        if (regs->msr & MSR_LE) {
+                flags ^= SW;
+                /*
+                 * So-called "PowerPC little endian" mode works by
+                 * swizzling addresses rather than by actually doing
+                 * any byte-swapping.  To emulate this, we XOR each
+                 * byte address with 7.  We also byte-swap, because
+                 * the processor's address swizzling depends on the
+                 * operand size (it xors the address with 7 for bytes,
+                 * 6 for halfwords, 4 for words, 0 for doublewords) but
+                 * we will xor with 7 and load/store each byte separately.
+                 */
+                if (cpu_has_feature(CPU_FTR_PPC_LE))
+                        swiz = 7;
+        }
+
         /* DAR has the operand effective address */
         addr = (unsigned char __user *)regs->dar;
 
@@ -412,7 +448,8 @@ int fix_alignment(struct pt_regs *regs)
          * function
          */
         if (flags & M)
-                return emulate_multiple(regs, addr, reg, nb, flags, instr);
+                return emulate_multiple(regs, addr, reg, nb,
+                                        flags, instr, swiz);
 
         /* Verify the address of the operand */
         if (unlikely(user_mode(regs) &&
@@ -431,51 +468,71 @@ int fix_alignment(struct pt_regs *regs)
         /* If we are loading, get the data from user space, else
          * get it from register values
          */
-        if (flags & LD) {
+        if (!(flags & ST)) {
                 data.ll = 0;
                 ret = 0;
-                p = addr;
+                p = (unsigned long) addr;
                 switch (nb) {
                 case 8:
-                        ret |= __get_user(data.v[0], p++);
-                        ret |= __get_user(data.v[1], p++);
-                        ret |= __get_user(data.v[2], p++);
-                        ret |= __get_user(data.v[3], p++);
+                        ret |= __get_user(data.v[0], SWIZ_PTR(p++));
+                        ret |= __get_user(data.v[1], SWIZ_PTR(p++));
+                        ret |= __get_user(data.v[2], SWIZ_PTR(p++));
+                        ret |= __get_user(data.v[3], SWIZ_PTR(p++));
                 case 4:
-                        ret |= __get_user(data.v[4], p++);
-                        ret |= __get_user(data.v[5], p++);
+                        ret |= __get_user(data.v[4], SWIZ_PTR(p++));
+                        ret |= __get_user(data.v[5], SWIZ_PTR(p++));
                 case 2:
-                        ret |= __get_user(data.v[6], p++);
-                        ret |= __get_user(data.v[7], p++);
+                        ret |= __get_user(data.v[6], SWIZ_PTR(p++));
+                        ret |= __get_user(data.v[7], SWIZ_PTR(p++));
                         if (unlikely(ret))
                                 return -EFAULT;
                 }
-        } else if (flags & F)
+        } else if (flags & F) {
                 data.dd = current->thread.fpr[reg];
-        else
+                if (flags & S) {
+                        /* Single-precision FP store requires conversion... */
+#ifdef CONFIG_PPC_FPU
+                        preempt_disable();
+                        enable_kernel_fp();
+                        cvt_df(&data.dd, (float *)&data.v[4], &current->thread);
+                        preempt_enable();
+#else
+                        return 0;
+#endif
+                }
+        } else
                 data.ll = regs->gpr[reg];
 
-        /* Perform other misc operations like sign extension, byteswap,
+        if (flags & SW) {
+                switch (nb) {
+                case 8:
+                        SWAP(data.v[0], data.v[7]);
+                        SWAP(data.v[1], data.v[6]);
+                        SWAP(data.v[2], data.v[5]);
+                        SWAP(data.v[3], data.v[4]);
+                        break;
+                case 4:
+                        SWAP(data.v[4], data.v[7]);
+                        SWAP(data.v[5], data.v[6]);
+                        break;
+                case 2:
+                        SWAP(data.v[6], data.v[7]);
+                        break;
+                }
+        }
+
+        /* Perform other misc operations like sign extension
          * or floating point single precision conversion
          */
-        switch (flags & ~U) {
+        switch (flags & ~(U|SW)) {
         case LD+SE:     /* sign extend */
                 if ( nb == 2 )
                         data.ll = data.x16.low16;
                 else    /* nb must be 4 */
                         data.ll = data.x32.low32;
                 break;
-        case LD+S:      /* byte-swap */
-        case ST+S:
-                if (nb == 2) {
-                        SWAP(data.v[6], data.v[7]);
-                } else {
-                        SWAP(data.v[4], data.v[7]);
-                        SWAP(data.v[5], data.v[6]);
-                }
-                break;
 
-        /* Single-precision FP load and store require conversions... */
+        /* Single-precision FP load requires conversion... */
         case LD+F+S:
 #ifdef CONFIG_PPC_FPU
                 preempt_disable();
@@ -486,34 +543,24 @@ int fix_alignment(struct pt_regs *regs)
                 return 0;
 #endif
                 break;
-        case ST+F+S:
-#ifdef CONFIG_PPC_FPU
-                preempt_disable();
-                enable_kernel_fp();
-                cvt_df(&data.dd, (float *)&data.v[4], &current->thread);
-                preempt_enable();
-#else
-                return 0;
-#endif
-                break;
         }
 
         /* Store result to memory or update registers */
         if (flags & ST) {
                 ret = 0;
-                p = addr;
+                p = (unsigned long) addr;
                 switch (nb) {
                 case 8:
-                        ret |= __put_user(data.v[0], p++);
-                        ret |= __put_user(data.v[1], p++);
-                        ret |= __put_user(data.v[2], p++);
-                        ret |= __put_user(data.v[3], p++);
+                        ret |= __put_user(data.v[0], SWIZ_PTR(p++));
+                        ret |= __put_user(data.v[1], SWIZ_PTR(p++));
+                        ret |= __put_user(data.v[2], SWIZ_PTR(p++));
+                        ret |= __put_user(data.v[3], SWIZ_PTR(p++));
                 case 4:
-                        ret |= __put_user(data.v[4], p++);
-                        ret |= __put_user(data.v[5], p++);
+                        ret |= __put_user(data.v[4], SWIZ_PTR(p++));
+                        ret |= __put_user(data.v[5], SWIZ_PTR(p++));
                 case 2:
-                        ret |= __put_user(data.v[6], p++);
-                        ret |= __put_user(data.v[7], p++);
+                        ret |= __put_user(data.v[6], SWIZ_PTR(p++));
+                        ret |= __put_user(data.v[7], SWIZ_PTR(p++));
                 }
                 if (unlikely(ret))
                         return -EFAULT;
diff --git a/arch/powerpc/kernel/asm-offsets.c b/arch/powerpc/kernel/asm-offsets.c
index 8f85c5e8a55a..ff2940548929 100644
--- a/arch/powerpc/kernel/asm-offsets.c
+++ b/arch/powerpc/kernel/asm-offsets.c
@@ -122,9 +122,8 @@ int main(void)
         DEFINE(PACASLBCACHE, offsetof(struct paca_struct, slb_cache));
         DEFINE(PACASLBCACHEPTR, offsetof(struct paca_struct, slb_cache_ptr));
         DEFINE(PACACONTEXTID, offsetof(struct paca_struct, context.id));
-#ifdef CONFIG_PPC_64K_PAGES
-        DEFINE(PACAPGDIR, offsetof(struct paca_struct, pgdir));
-#endif
+        DEFINE(PACACONTEXTSLLP, offsetof(struct paca_struct, context.sllp));
+        DEFINE(PACAVMALLOCSLLP, offsetof(struct paca_struct, vmalloc_sllp));
 #ifdef CONFIG_HUGETLB_PAGE
         DEFINE(PACALOWHTLBAREAS, offsetof(struct paca_struct, context.low_htlb_areas));
         DEFINE(PACAHIGHHTLBAREAS, offsetof(struct paca_struct, context.high_htlb_areas));
diff --git a/arch/powerpc/kernel/cpu_setup_6xx.S b/arch/powerpc/kernel/cpu_setup_6xx.S
index 55ed7716636f..365381fcb27c 100644
--- a/arch/powerpc/kernel/cpu_setup_6xx.S
+++ b/arch/powerpc/kernel/cpu_setup_6xx.S
@@ -210,9 +210,11 @@ setup_745x_specifics:
          * the firmware. If any, we disable NAP capability as
          * it's known to be bogus on rev 2.1 and earlier
          */
+BEGIN_FTR_SECTION
         mfspr   r11,SPRN_L3CR
         andis.  r11,r11,L3CR_L3E@h
         beq     1f
+END_FTR_SECTION_IFSET(CPU_FTR_L3CR)
         lwz     r6,CPU_SPEC_FEATURES(r5)
         andi.   r0,r6,CPU_FTR_L3_DISABLE_NAP
         beq     1f
diff --git a/arch/powerpc/kernel/cpu_setup_power4.S b/arch/powerpc/kernel/cpu_setup_power4.S
index b61d86e7ceb6..271418308d53 100644
--- a/arch/powerpc/kernel/cpu_setup_power4.S
+++ b/arch/powerpc/kernel/cpu_setup_power4.S
@@ -73,23 +73,6 @@ _GLOBAL(__970_cpu_preinit)
         isync
         blr
 
-_GLOBAL(__setup_cpu_power4)
-        blr
-
-_GLOBAL(__setup_cpu_be)
-        /* Set large page sizes LP=0: 16MB, LP=1: 64KB */
-        addi    r3, 0,  0
-        ori     r3, r3, HID6_LB
-        sldi    r3, r3, 32
-        nor     r3, r3, r3
-        mfspr   r4, SPRN_HID6
-        and     r4, r4, r3
-        addi    r3, 0, 0x02000
-        sldi    r3, r3, 32
-        or      r4, r4, r3
-        mtspr   SPRN_HID6, r4
-        blr
-
 _GLOBAL(__setup_cpu_ppc970)
         mfspr   r0,SPRN_HID0
         li      r11,5                   /* clear DOZE and SLEEP */
diff --git a/arch/powerpc/kernel/cputable.c b/arch/powerpc/kernel/cputable.c
index 3f7182db9ed5..1c114880dc05 100644
--- a/arch/powerpc/kernel/cputable.c
+++ b/arch/powerpc/kernel/cputable.c
@@ -30,11 +30,7 @@ EXPORT_SYMBOL(cur_cpu_spec);
  * part of the cputable though. That has to be fixed for both ppc32
  * and ppc64
  */
-#ifdef CONFIG_PPC64
-extern void __setup_cpu_power3(unsigned long offset, struct cpu_spec* spec);
-extern void __setup_cpu_power4(unsigned long offset, struct cpu_spec* spec);
-extern void __setup_cpu_be(unsigned long offset, struct cpu_spec* spec);
-#else
+#ifdef CONFIG_PPC32
 extern void __setup_cpu_603(unsigned long offset, struct cpu_spec* spec);
 extern void __setup_cpu_604(unsigned long offset, struct cpu_spec* spec);
 extern void __setup_cpu_750(unsigned long offset, struct cpu_spec* spec);
@@ -58,7 +54,8 @@ extern void __setup_cpu_ppc970(unsigned long offset, struct cpu_spec* spec);
 #define COMMON_USER_POWER5_PLUS (COMMON_USER_PPC64 | PPC_FEATURE_POWER5_PLUS|\
                                  PPC_FEATURE_SMT | PPC_FEATURE_ICACHE_SNOOP)
 #define COMMON_USER_POWER6      (COMMON_USER_PPC64 | PPC_FEATURE_ARCH_2_05 |\
-                                 PPC_FEATURE_SMT | PPC_FEATURE_ICACHE_SNOOP)
+                                 PPC_FEATURE_SMT | PPC_FEATURE_ICACHE_SNOOP | \
+                                 PPC_FEATURE_TRUE_LE)
 #define COMMON_USER_BOOKE       (PPC_FEATURE_32 | PPC_FEATURE_HAS_MMU | \
                                  PPC_FEATURE_BOOKE)
 
@@ -78,11 +75,10 @@ struct cpu_spec	cpu_specs[] = {
                 .pvr_value              = 0x00400000,
                 .cpu_name               = "POWER3 (630)",
                 .cpu_features           = CPU_FTRS_POWER3,
-                .cpu_user_features      = COMMON_USER_PPC64,
+                .cpu_user_features      = COMMON_USER_PPC64|PPC_FEATURE_PPC_LE,
                 .icache_bsize           = 128,
                 .dcache_bsize           = 128,
                 .num_pmcs               = 8,
-                .cpu_setup              = __setup_cpu_power3,
                 .oprofile_cpu_type      = "ppc64/power3",
                 .oprofile_type          = PPC_OPROFILE_RS64,
                 .platform               = "power3",
@@ -92,11 +88,10 @@ struct cpu_spec	cpu_specs[] = {
                 .pvr_value              = 0x00410000,
                 .cpu_name               = "POWER3 (630+)",
                 .cpu_features           = CPU_FTRS_POWER3,
-                .cpu_user_features      = COMMON_USER_PPC64,
+                .cpu_user_features      = COMMON_USER_PPC64|PPC_FEATURE_PPC_LE,
                 .icache_bsize           = 128,
                 .dcache_bsize           = 128,
                 .num_pmcs               = 8,
-                .cpu_setup              = __setup_cpu_power3,
                 .oprofile_cpu_type      = "ppc64/power3",
                 .oprofile_type          = PPC_OPROFILE_RS64,
                 .platform               = "power3",
@@ -110,7 +105,6 @@ struct cpu_spec	cpu_specs[] = {
                 .icache_bsize           = 128,
                 .dcache_bsize           = 128,
                 .num_pmcs               = 8,
-                .cpu_setup              = __setup_cpu_power3,
                 .oprofile_cpu_type      = "ppc64/rs64",
                 .oprofile_type          = PPC_OPROFILE_RS64,
                 .platform               = "rs64",
@@ -124,7 +118,6 @@ struct cpu_spec	cpu_specs[] = {
                 .icache_bsize           = 128,
                 .dcache_bsize           = 128,
                 .num_pmcs               = 8,
-                .cpu_setup              = __setup_cpu_power3,
                 .oprofile_cpu_type      = "ppc64/rs64",
                 .oprofile_type          = PPC_OPROFILE_RS64,
                 .platform               = "rs64",
@@ -138,7 +131,6 @@ struct cpu_spec	cpu_specs[] = {
                 .icache_bsize           = 128,
                 .dcache_bsize           = 128,
                 .num_pmcs               = 8,
-                .cpu_setup              = __setup_cpu_power3,
                 .oprofile_cpu_type      = "ppc64/rs64",
                 .oprofile_type          = PPC_OPROFILE_RS64,
                 .platform               = "rs64",
@@ -152,7 +144,6 @@ struct cpu_spec	cpu_specs[] = {
                 .icache_bsize           = 128,
                 .dcache_bsize           = 128,
                 .num_pmcs               = 8,
-                .cpu_setup              = __setup_cpu_power3,
                 .oprofile_cpu_type      = "ppc64/rs64",
                 .oprofile_type          = PPC_OPROFILE_RS64,
                 .platform               = "rs64",
@@ -166,7 +157,6 @@ struct cpu_spec	cpu_specs[] = {
                 .icache_bsize           = 128,
                 .dcache_bsize           = 128,
                 .num_pmcs               = 8,
-                .cpu_setup              = __setup_cpu_power4,
                 .oprofile_cpu_type      = "ppc64/power4",
                 .oprofile_type          = PPC_OPROFILE_POWER4,
                 .platform               = "power4",
@@ -180,7 +170,6 @@ struct cpu_spec	cpu_specs[] = {
                 .icache_bsize           = 128,
                 .dcache_bsize           = 128,
                 .num_pmcs               = 8,
-                .cpu_setup              = __setup_cpu_power4,
                 .oprofile_cpu_type      = "ppc64/power4",
                 .oprofile_type          = PPC_OPROFILE_POWER4,
                 .platform               = "power4",
@@ -200,17 +189,11 @@ struct cpu_spec	cpu_specs[] = {
                 .oprofile_type          = PPC_OPROFILE_POWER4,
                 .platform               = "ppc970",
         },
-#endif /* CONFIG_PPC64 */
-#if defined(CONFIG_PPC64) || defined(CONFIG_POWER4)
         {       /* PPC970FX */
                 .pvr_mask               = 0xffff0000,
                 .pvr_value              = 0x003c0000,
                 .cpu_name               = "PPC970FX",
-#ifdef CONFIG_PPC32
-                .cpu_features           = CPU_FTRS_970_32,
-#else
                 .cpu_features           = CPU_FTRS_PPC970,
-#endif
                 .cpu_user_features      = COMMON_USER_POWER4 |
                         PPC_FEATURE_HAS_ALTIVEC_COMP,
                 .icache_bsize           = 128,
@@ -221,8 +204,6 @@ struct cpu_spec	cpu_specs[] = {
                 .oprofile_type          = PPC_OPROFILE_POWER4,
                 .platform               = "ppc970",
         },
-#endif /* defined(CONFIG_PPC64) || defined(CONFIG_POWER4) */
-#ifdef CONFIG_PPC64
         {       /* PPC970MP */
                 .pvr_mask               = 0xffff0000,
                 .pvr_value              = 0x00440000,
@@ -232,6 +213,7 @@ struct cpu_spec	cpu_specs[] = {
                         PPC_FEATURE_HAS_ALTIVEC_COMP,
                 .icache_bsize           = 128,
                 .dcache_bsize           = 128,
+                .num_pmcs               = 8,
                 .cpu_setup              = __setup_cpu_ppc970,
                 .oprofile_cpu_type      = "ppc64/970",
                 .oprofile_type          = PPC_OPROFILE_POWER4,
@@ -246,9 +228,13 @@ struct cpu_spec	cpu_specs[] = {
                 .icache_bsize           = 128,
                 .dcache_bsize           = 128,
                 .num_pmcs               = 6,
-                .cpu_setup              = __setup_cpu_power4,
                 .oprofile_cpu_type      = "ppc64/power5",
                 .oprofile_type          = PPC_OPROFILE_POWER4,
+                /* SIHV / SIPR bits are implemented on POWER4+ (GQ)
+                 * and above but only works on POWER5 and above
+                 */
+                .oprofile_mmcra_sihv    = MMCRA_SIHV,
+                .oprofile_mmcra_sipr    = MMCRA_SIPR,
                 .platform               = "power5",
         },
         {       /* Power5 GS */
@@ -260,9 +246,10 @@ struct cpu_spec	cpu_specs[] = {
                 .icache_bsize           = 128,
                 .dcache_bsize           = 128,
                 .num_pmcs               = 6,
-                .cpu_setup              = __setup_cpu_power4,
                 .oprofile_cpu_type      = "ppc64/power5+",
                 .oprofile_type          = PPC_OPROFILE_POWER4,
+                .oprofile_mmcra_sihv    = MMCRA_SIHV,
+                .oprofile_mmcra_sipr    = MMCRA_SIPR,
                 .platform               = "power5+",
         },
         {       /* Power6 */
@@ -273,10 +260,13 @@ struct cpu_spec	cpu_specs[] = {
                 .cpu_user_features      = COMMON_USER_POWER6,
                 .icache_bsize           = 128,
                 .dcache_bsize           = 128,
-                .num_pmcs               = 6,
-                .cpu_setup              = __setup_cpu_power4,
+                .num_pmcs               = 8,
                 .oprofile_cpu_type      = "ppc64/power6",
                 .oprofile_type          = PPC_OPROFILE_POWER4,
+                .oprofile_mmcra_sihv    = POWER6_MMCRA_SIHV,
+                .oprofile_mmcra_sipr    = POWER6_MMCRA_SIPR,
+                .oprofile_mmcra_clear   = POWER6_MMCRA_THRM |
+                        POWER6_MMCRA_OTHER,
                 .platform               = "power6",
         },
         {       /* Cell Broadband Engine */
@@ -289,7 +279,6 @@ struct cpu_spec	cpu_specs[] = {
                         PPC_FEATURE_SMT,
                 .icache_bsize           = 128,
                 .dcache_bsize           = 128,
-                .cpu_setup              = __setup_cpu_be,
                 .platform               = "ppc-cell-be",
         },
         {       /* default match */
@@ -301,7 +290,6 @@ struct cpu_spec	cpu_specs[] = {
                 .icache_bsize           = 128,
                 .dcache_bsize           = 128,
                 .num_pmcs               = 6,
-                .cpu_setup              = __setup_cpu_power4,
                 .platform               = "power4",
         }
 #endif  /* CONFIG_PPC64 */
@@ -323,7 +311,7 @@ struct cpu_spec	cpu_specs[] = {
                 .pvr_value              = 0x00030000,
                 .cpu_name               = "603",
                 .cpu_features           = CPU_FTRS_603,
-                .cpu_user_features      = COMMON_USER,
+                .cpu_user_features      = COMMON_USER | PPC_FEATURE_PPC_LE,
                 .icache_bsize           = 32,
                 .dcache_bsize           = 32,
                 .cpu_setup              = __setup_cpu_603,
@@ -334,7 +322,7 @@ struct cpu_spec	cpu_specs[] = {
                 .pvr_value              = 0x00060000,
                 .cpu_name               = "603e",
                 .cpu_features           = CPU_FTRS_603,
-                .cpu_user_features      = COMMON_USER,
+                .cpu_user_features      = COMMON_USER | PPC_FEATURE_PPC_LE,
                 .icache_bsize           = 32,
                 .dcache_bsize           = 32,
                 .cpu_setup              = __setup_cpu_603,
@@ -345,7 +333,7 @@ struct cpu_spec	cpu_specs[] = {
                 .pvr_value              = 0x00070000,
                 .cpu_name               = "603ev",
                 .cpu_features           = CPU_FTRS_603,
-                .cpu_user_features      = COMMON_USER,
+                .cpu_user_features      = COMMON_USER | PPC_FEATURE_PPC_LE,
                 .icache_bsize           = 32,
                 .dcache_bsize           = 32,
                 .cpu_setup              = __setup_cpu_603,
@@ -356,7 +344,7 @@ struct cpu_spec	cpu_specs[] = {
                 .pvr_value              = 0x00040000,
                 .cpu_name               = "604",
                 .cpu_features           = CPU_FTRS_604,
-                .cpu_user_features      = COMMON_USER,
+                .cpu_user_features      = COMMON_USER | PPC_FEATURE_PPC_LE,
                 .icache_bsize           = 32,
                 .dcache_bsize           = 32,
                 .num_pmcs               = 2,
@@ -368,7 +356,7 @@ struct cpu_spec	cpu_specs[] = {
                 .pvr_value              = 0x00090000,
                 .cpu_name               = "604e",
                 .cpu_features           = CPU_FTRS_604,
-                .cpu_user_features      = COMMON_USER,
+                .cpu_user_features      = COMMON_USER | PPC_FEATURE_PPC_LE,
                 .icache_bsize           = 32,
                 .dcache_bsize           = 32,
                 .num_pmcs               = 4,
@@ -380,7 +368,7 @@ struct cpu_spec	cpu_specs[] = {
                 .pvr_value              = 0x00090000,
                 .cpu_name               = "604r",
                 .cpu_features           = CPU_FTRS_604,
-                .cpu_user_features      = COMMON_USER,
+                .cpu_user_features      = COMMON_USER | PPC_FEATURE_PPC_LE,
                 .icache_bsize           = 32,
                 .dcache_bsize           = 32,
                 .num_pmcs               = 4,
@@ -392,7 +380,7 @@ struct cpu_spec	cpu_specs[] = {
                 .pvr_value              = 0x000a0000,
                 .cpu_name               = "604ev",
                 .cpu_features           = CPU_FTRS_604,
-                .cpu_user_features      = COMMON_USER,
+                .cpu_user_features      = COMMON_USER | PPC_FEATURE_PPC_LE,
                 .icache_bsize           = 32,
                 .dcache_bsize           = 32,
                 .num_pmcs               = 4,
@@ -404,7 +392,7 @@ struct cpu_spec	cpu_specs[] = {
                 .pvr_value              = 0x00084202,
                 .cpu_name               = "740/750",
                 .cpu_features           = CPU_FTRS_740_NOTAU,
-                .cpu_user_features      = COMMON_USER,
+                .cpu_user_features      = COMMON_USER | PPC_FEATURE_PPC_LE,
                 .icache_bsize           = 32,
                 .dcache_bsize           = 32,
                 .num_pmcs               = 4,
@@ -416,7 +404,7 @@ struct cpu_spec	cpu_specs[] = {
                 .pvr_value              = 0x00080100,
                 .cpu_name               = "750CX",
                 .cpu_features           = CPU_FTRS_750,
-                .cpu_user_features      = COMMON_USER,
+                .cpu_user_features      = COMMON_USER | PPC_FEATURE_PPC_LE,
                 .icache_bsize           = 32,
                 .dcache_bsize           = 32,
                 .num_pmcs               = 4,
@@ -428,7 +416,7 @@ struct cpu_spec	cpu_specs[] = {
                 .pvr_value              = 0x00082200,
                 .cpu_name               = "750CX",
                 .cpu_features           = CPU_FTRS_750,
-                .cpu_user_features      = COMMON_USER,
+                .cpu_user_features      = COMMON_USER | PPC_FEATURE_PPC_LE,
                 .icache_bsize           = 32,
                 .dcache_bsize           = 32,
                 .num_pmcs               = 4,
@@ -440,7 +428,7 @@ struct cpu_spec	cpu_specs[] = {
                 .pvr_value              = 0x00082210,
                 .cpu_name               = "750CXe",
                 .cpu_features           = CPU_FTRS_750,
-                .cpu_user_features      = COMMON_USER,
+                .cpu_user_features      = COMMON_USER | PPC_FEATURE_PPC_LE,
                 .icache_bsize           = 32,
                 .dcache_bsize           = 32,
                 .num_pmcs               = 4,
@@ -452,7 +440,7 @@ struct cpu_spec	cpu_specs[] = {
                 .pvr_value              = 0x00083214,
                 .cpu_name               = "750CXe",
                 .cpu_features           = CPU_FTRS_750,
-                .cpu_user_features      = COMMON_USER,
+                .cpu_user_features      = COMMON_USER | PPC_FEATURE_PPC_LE,
                 .icache_bsize           = 32,
                 .dcache_bsize           = 32,
                 .num_pmcs               = 4,
@@ -464,7 +452,7 @@ struct cpu_spec	cpu_specs[] = {
                 .pvr_value              = 0x00083000,
                 .cpu_name               = "745/755",
                 .cpu_features           = CPU_FTRS_750,
-                .cpu_user_features      = COMMON_USER,
+                .cpu_user_features      = COMMON_USER | PPC_FEATURE_PPC_LE,
                 .icache_bsize           = 32,
                 .dcache_bsize           = 32,
                 .num_pmcs               = 4,
@@ -476,7 +464,7 @@ struct cpu_spec	cpu_specs[] = {
                 .pvr_value              = 0x70000100,
                 .cpu_name               = "750FX",
                 .cpu_features           = CPU_FTRS_750FX1,
-                .cpu_user_features      = COMMON_USER,
+                .cpu_user_features      = COMMON_USER | PPC_FEATURE_PPC_LE,
                 .icache_bsize           = 32,
                 .dcache_bsize           = 32,
                 .num_pmcs               = 4,
@@ -488,7 +476,7 @@ struct cpu_spec	cpu_specs[] = {
                 .pvr_value              = 0x70000200,
                 .cpu_name               = "750FX",
                 .cpu_features           = CPU_FTRS_750FX2,
-                .cpu_user_features      = COMMON_USER,
+                .cpu_user_features      = COMMON_USER | PPC_FEATURE_PPC_LE,
                 .icache_bsize           = 32,
                 .dcache_bsize           = 32,
                 .num_pmcs               = 4,
@@ -500,7 +488,7 @@ struct cpu_spec	cpu_specs[] = {
                 .pvr_value              = 0x70000000,
                 .cpu_name               = "750FX",
                 .cpu_features           = CPU_FTRS_750FX,
-                .cpu_user_features      = COMMON_USER,
+                .cpu_user_features      = COMMON_USER | PPC_FEATURE_PPC_LE,
                 .icache_bsize           = 32,
                 .dcache_bsize           = 32,
                 .num_pmcs               = 4,
@@ -512,7 +500,7 @@ struct cpu_spec	cpu_specs[] = {
                 .pvr_value              = 0x70020000,
                 .cpu_name               = "750GX",
                 .cpu_features           = CPU_FTRS_750GX,
-                .cpu_user_features      = COMMON_USER,
+                .cpu_user_features      = COMMON_USER | PPC_FEATURE_PPC_LE,
                 .icache_bsize           = 32,
                 .dcache_bsize           = 32,
                 .num_pmcs               = 4,
@@ -524,7 +512,7 @@ struct cpu_spec	cpu_specs[] = {
                 .pvr_value              = 0x00080000,
                 .cpu_name               = "740/750",
                 .cpu_features           = CPU_FTRS_740,
-                .cpu_user_features      = COMMON_USER,
+                .cpu_user_features      = COMMON_USER | PPC_FEATURE_PPC_LE,
                 .icache_bsize           = 32,
                 .dcache_bsize           = 32,
                 .num_pmcs               = 4,
@@ -536,7 +524,8 @@ struct cpu_spec	cpu_specs[] = {
                 .pvr_value              = 0x000c1101,
                 .cpu_name               = "7400 (1.1)",
                 .cpu_features           = CPU_FTRS_7400_NOTAU,
-                .cpu_user_features      = COMMON_USER | PPC_FEATURE_HAS_ALTIVEC_COMP,
+                .cpu_user_features      = COMMON_USER |
+                        PPC_FEATURE_HAS_ALTIVEC_COMP | PPC_FEATURE_PPC_LE,
                 .icache_bsize           = 32,
                 .dcache_bsize           = 32,
                 .num_pmcs               = 4,
@@ -548,7 +537,8 @@ struct cpu_spec	cpu_specs[] = {
                 .pvr_value              = 0x000c0000,
                 .cpu_name               = "7400",
                 .cpu_features           = CPU_FTRS_7400,
-                .cpu_user_features      = COMMON_USER | PPC_FEATURE_HAS_ALTIVEC_COMP,
+                .cpu_user_features      = COMMON_USER |
+                        PPC_FEATURE_HAS_ALTIVEC_COMP | PPC_FEATURE_PPC_LE,
                 .icache_bsize           = 32,
                 .dcache_bsize           = 32,
                 .num_pmcs               = 4,
@@ -560,7 +550,8 @@ struct cpu_spec	cpu_specs[] = {
                 .pvr_value              = 0x800c0000,
                 .cpu_name               = "7410",
                 .cpu_features           = CPU_FTRS_7400,
-                .cpu_user_features      = COMMON_USER | PPC_FEATURE_HAS_ALTIVEC_COMP,
+                .cpu_user_features      = COMMON_USER |
+                        PPC_FEATURE_HAS_ALTIVEC_COMP | PPC_FEATURE_PPC_LE,
                 .icache_bsize           = 32,
                 .dcache_bsize           = 32,
                 .num_pmcs               = 4,
@@ -572,7 +563,8 @@ struct cpu_spec	cpu_specs[] = {
                 .pvr_value              = 0x80000200,
                 .cpu_name               = "7450",
                 .cpu_features           = CPU_FTRS_7450_20,
-                .cpu_user_features      = COMMON_USER | PPC_FEATURE_HAS_ALTIVEC_COMP,
+                .cpu_user_features      = COMMON_USER |
+                        PPC_FEATURE_HAS_ALTIVEC_COMP | PPC_FEATURE_PPC_LE,
                 .icache_bsize           = 32,
                 .dcache_bsize           = 32,
                 .num_pmcs               = 6,
@@ -586,7 +578,8 @@ struct cpu_spec	cpu_specs[] = {
                 .pvr_value              = 0x80000201,
                 .cpu_name               = "7450",
                 .cpu_features           = CPU_FTRS_7450_21,
-                .cpu_user_features      = COMMON_USER | PPC_FEATURE_HAS_ALTIVEC_COMP,
+                .cpu_user_features      = COMMON_USER |
+                        PPC_FEATURE_HAS_ALTIVEC_COMP | PPC_FEATURE_PPC_LE,
                 .icache_bsize           = 32,
                 .dcache_bsize           = 32,
                 .num_pmcs               = 6,
@@ -600,7 +593,8 @@ struct cpu_spec	cpu_specs[] = {
                 .pvr_value              = 0x80000000,
                 .cpu_name               = "7450",
                 .cpu_features           = CPU_FTRS_7450_23,
-                .cpu_user_features      = COMMON_USER | PPC_FEATURE_HAS_ALTIVEC_COMP,
+                .cpu_user_features      = COMMON_USER |
+                        PPC_FEATURE_HAS_ALTIVEC_COMP | PPC_FEATURE_PPC_LE,
                 .icache_bsize           = 32,
                 .dcache_bsize           = 32,
                 .num_pmcs               = 6,
@@ -614,7 +608,8 @@ struct cpu_spec	cpu_specs[] = {
                 .pvr_value              = 0x80010100,
                 .cpu_name               = "7455",
                 .cpu_features           = CPU_FTRS_7455_1,
-                .cpu_user_features      = COMMON_USER | PPC_FEATURE_HAS_ALTIVEC_COMP,
+                .cpu_user_features      = COMMON_USER |
+                        PPC_FEATURE_HAS_ALTIVEC_COMP | PPC_FEATURE_PPC_LE,
                 .icache_bsize           = 32,
                 .dcache_bsize           = 32,
                 .num_pmcs               = 6,
@@ -628,7 +623,8 @@ struct cpu_spec	cpu_specs[] = {
                 .pvr_value              = 0x80010200,
                 .cpu_name               = "7455",
                 .cpu_features           = CPU_FTRS_7455_20,
-                .cpu_user_features      = COMMON_USER | PPC_FEATURE_HAS_ALTIVEC_COMP,
+                .cpu_user_features      = COMMON_USER |
+                        PPC_FEATURE_HAS_ALTIVEC_COMP | PPC_FEATURE_PPC_LE,
                 .icache_bsize           = 32,
                 .dcache_bsize           = 32,
                 .num_pmcs               = 6,
@@ -642,7 +638,8 @@ struct cpu_spec	cpu_specs[] = {
                 .pvr_value              = 0x80010000,
                 .cpu_name               = "7455",
                 .cpu_features           = CPU_FTRS_7455,
-                .cpu_user_features      = COMMON_USER | PPC_FEATURE_HAS_ALTIVEC_COMP,
+                .cpu_user_features      = COMMON_USER |
+                        PPC_FEATURE_HAS_ALTIVEC_COMP | PPC_FEATURE_PPC_LE,
                 .icache_bsize           = 32,
                 .dcache_bsize           = 32,
                 .num_pmcs               = 6,
@@ -656,7 +653,8 @@ struct cpu_spec	cpu_specs[] = {
                 .pvr_value              = 0x80020100,
                 .cpu_name               = "7447/7457",
                 .cpu_features           = CPU_FTRS_7447_10,
-                .cpu_user_features      = COMMON_USER | PPC_FEATURE_HAS_ALTIVEC_COMP,
+                .cpu_user_features      = COMMON_USER |
+                        PPC_FEATURE_HAS_ALTIVEC_COMP | PPC_FEATURE_PPC_LE,
                 .icache_bsize           = 32,
                 .dcache_bsize           = 32,
                 .num_pmcs               = 6,
@@ -670,7 +668,8 @@ struct cpu_spec	cpu_specs[] = {
                 .pvr_value              = 0x80020101,
                 .cpu_name               = "7447/7457",
                 .cpu_features           = CPU_FTRS_7447_10,
-                .cpu_user_features      = COMMON_USER | PPC_FEATURE_HAS_ALTIVEC_COMP,
+                .cpu_user_features      = COMMON_USER |
+                        PPC_FEATURE_HAS_ALTIVEC_COMP | PPC_FEATURE_PPC_LE,
                 .icache_bsize           = 32,
                 .dcache_bsize           = 32,
                 .num_pmcs               = 6,
@@ -684,7 +683,7 @@ struct cpu_spec	cpu_specs[] = {
                 .pvr_value              = 0x80020000,
                 .cpu_name               = "7447/7457",
                 .cpu_features           = CPU_FTRS_7447,
-                .cpu_user_features      = COMMON_USER | PPC_FEATURE_HAS_ALTIVEC_COMP,
+                .cpu_user_features      = COMMON_USER | PPC_FEATURE_HAS_ALTIVEC_COMP | PPC_FEATURE_PPC_LE,
                 .icache_bsize           = 32,
                 .dcache_bsize           = 32,
                 .num_pmcs               = 6,
@@ -698,7 +697,8 @@ struct cpu_spec	cpu_specs[] = {
                 .pvr_value              = 0x80030000,
                 .cpu_name               = "7447A",
                 .cpu_features           = CPU_FTRS_7447A,
-                .cpu_user_features      = COMMON_USER | PPC_FEATURE_HAS_ALTIVEC_COMP,
+                .cpu_user_features      = COMMON_USER |
+                        PPC_FEATURE_HAS_ALTIVEC_COMP | PPC_FEATURE_PPC_LE,
                 .icache_bsize           = 32,
                 .dcache_bsize           = 32,
                 .num_pmcs               = 6,
@@ -712,7 +712,8 @@ struct cpu_spec	cpu_specs[] = {
                 .pvr_value              = 0x80040000,
                 .cpu_name               = "7448",
                 .cpu_features           = CPU_FTRS_7447A,
-                .cpu_user_features      = COMMON_USER | PPC_FEATURE_HAS_ALTIVEC_COMP,
+                .cpu_user_features      = COMMON_USER |
+                        PPC_FEATURE_HAS_ALTIVEC_COMP | PPC_FEATURE_PPC_LE,
                 .icache_bsize           = 32,
                 .dcache_bsize           = 32,
                 .num_pmcs               = 6,
@@ -721,6 +722,18 @@ struct cpu_spec	cpu_specs[] = {
                 .oprofile_type          = PPC_OPROFILE_G4,
                 .platform               = "ppc7450",
         },
+        {       /* 8641 */
+               .pvr_mask               = 0xffffffff,
+               .pvr_value              = 0x80040010,
+               .cpu_name               = "8641",
+               .cpu_features           = CPU_FTRS_7447A,
+               .cpu_user_features      = COMMON_USER | PPC_FEATURE_HAS_ALTIVEC_COMP,
+               .icache_bsize           = 32,
+               .dcache_bsize           = 32,
+               .num_pmcs               = 6,
+               .cpu_setup              = __setup_cpu_745x
+        },
+
         {       /* 82xx (8240, 8245, 8260 are all 603e cores) */
                 .pvr_mask               = 0x7fff0000,
                 .pvr_value              = 0x00810000,
diff --git a/arch/powerpc/kernel/crash.c b/arch/powerpc/kernel/crash.c
index 778f22fd85d2..dbcb85994f46 100644
--- a/arch/powerpc/kernel/crash.c
+++ b/arch/powerpc/kernel/crash.c
@@ -22,6 +22,7 @@
 #include <linux/elf.h>
 #include <linux/elfcore.h>
 #include <linux/init.h>
+#include <linux/irq.h>
 #include <linux/types.h>
 
 #include <asm/processor.h>
@@ -174,6 +175,8 @@ static void crash_kexec_prepare_cpus(void)
 
 void default_machine_crash_shutdown(struct pt_regs *regs)
 {
+        unsigned int irq;
+
         /*
          * This function is only called after the system
          * has paniced or is otherwise in a critical state.
@@ -186,6 +189,16 @@ void default_machine_crash_shutdown(struct pt_regs *regs)
          */
         local_irq_disable();
 
+        for_each_irq(irq) {
+                struct irq_desc *desc = irq_descp(irq);
+
+                if (desc->status & IRQ_INPROGRESS)
+                        desc->handler->end(irq);
+
+                if (!(desc->status & IRQ_DISABLED))
+                        desc->handler->disable(irq);
+        }
+
         if (ppc_md.kexec_cpu_down)
                 ppc_md.kexec_cpu_down(1, 0);
 
diff --git a/arch/powerpc/kernel/crash_dump.c b/arch/powerpc/kernel/crash_dump.c
index 764d07329716..371973be8d71 100644
--- a/arch/powerpc/kernel/crash_dump.c
+++ b/arch/powerpc/kernel/crash_dump.c
@@ -25,6 +25,11 @@
 #define DBG(fmt...)
 #endif
 
+void reserve_kdump_trampoline(void)
+{
+        lmb_reserve(0, KDUMP_RESERVE_LIMIT);
+}
+
 static void __init create_trampoline(unsigned long addr)
 {
         /* The maximum range of a single instruction branch, is the current
@@ -39,11 +44,11 @@ static void __init create_trampoline(unsigned long addr)
         create_branch(addr + 4, addr + PHYSICAL_START, 0);
 }
 
-void __init kdump_setup(void)
+void __init setup_kdump_trampoline(void)
 {
         unsigned long i;
 
-        DBG(" -> kdump_setup()\n");
+        DBG(" -> setup_kdump_trampoline()\n");
 
         for (i = KDUMP_TRAMPOLINE_START; i < KDUMP_TRAMPOLINE_END; i += 8) {
                 create_trampoline(i);
@@ -52,7 +57,7 @@ void __init kdump_setup(void)
         create_trampoline(__pa(system_reset_fwnmi) - PHYSICAL_START);
         create_trampoline(__pa(machine_check_fwnmi) - PHYSICAL_START);
 
-        DBG(" <- kdump_setup()\n");
+        DBG(" <- setup_kdump_trampoline()\n");
 }
 
 #ifdef CONFIG_PROC_VMCORE
diff --git a/arch/powerpc/kernel/entry_64.S b/arch/powerpc/kernel/entry_64.S
index 19ad5c6b1818..221062c960c9 100644
--- a/arch/powerpc/kernel/entry_64.S
+++ b/arch/powerpc/kernel/entry_64.S
@@ -57,6 +57,7 @@ system_call_common:
         beq-    1f
         ld      r1,PACAKSAVE(r13)
 1:      std     r10,0(r1)
+        crclr   so
         std     r11,_NIP(r1)
         std     r12,_MSR(r1)
         std     r0,GPR0(r1)
@@ -75,7 +76,6 @@ system_call_common:
         std     r11,GPR11(r1)
         std     r11,GPR12(r1)
         std     r9,GPR13(r1)
-        crclr   so
         mfcr    r9
         mflr    r10
         li      r11,0xc01
diff --git a/arch/powerpc/kernel/fpu.S b/arch/powerpc/kernel/fpu.S
index 340730fb8c91..01f71200c603 100644
--- a/arch/powerpc/kernel/fpu.S
+++ b/arch/powerpc/kernel/fpu.S
@@ -72,7 +72,7 @@ _GLOBAL(load_up_fpu)
         std     r12,_MSR(r1)
 #endif
         lfd     fr0,THREAD_FPSCR(r5)
-        mtfsf   0xff,fr0
+        MTFSF_L(fr0)
         REST_32FPRS(0, r5)
 #ifndef CONFIG_SMP
         subi    r4,r5,THREAD
@@ -127,7 +127,7 @@ _GLOBAL(giveup_fpu)
 
 _GLOBAL(cvt_fd)
         lfd     0,THREAD_FPSCR(r5)      /* load up fpscr value */
-        mtfsf   0xff,0
+        MTFSF_L(0)
         lfs     0,0(r3)
         stfd    0,0(r4)
         mffs    0
@@ -136,7 +136,7 @@ _GLOBAL(cvt_fd)
 
 _GLOBAL(cvt_df)
         lfd     0,THREAD_FPSCR(r5)      /* load up fpscr value */
-        mtfsf   0xff,0
+        MTFSF_L(0)
         lfd     0,0(r3)
         stfs    0,0(r4)
         mffs    0
diff --git a/arch/powerpc/kernel/head_32.S b/arch/powerpc/kernel/head_32.S
index a0579e859b21..b25b25902d15 100644
--- a/arch/powerpc/kernel/head_32.S
+++ b/arch/powerpc/kernel/head_32.S
@@ -973,6 +973,13 @@ __secondary_start_gemini:
         b       __secondary_start
 #endif /* CONFIG_GEMINI */
 
+        .globl __secondary_start_mpc86xx
+__secondary_start_mpc86xx:
+        mfspr   r3, SPRN_PIR
+        stw     r3, __secondary_hold_acknowledge@l(0)
+        mr      r24, r3                 /* cpu # */
+        b       __secondary_start
+
         .globl  __secondary_start_pmac_0
 __secondary_start_pmac_0:
         /* NB the entries for cpus 0, 1, 2 must each occupy 8 bytes. */
@@ -1088,7 +1095,12 @@ load_up_mmu:
         LOAD_BAT(1,r3,r4,r5)
         LOAD_BAT(2,r3,r4,r5)
         LOAD_BAT(3,r3,r4,r5)
-
+BEGIN_FTR_SECTION
+        LOAD_BAT(4,r3,r4,r5)
+        LOAD_BAT(5,r3,r4,r5)
+        LOAD_BAT(6,r3,r4,r5)
+        LOAD_BAT(7,r3,r4,r5)
+END_FTR_SECTION_IFSET(CPU_FTR_HAS_HIGH_BATS)
         blr
 
 /*
diff --git a/arch/powerpc/kernel/head_64.S b/arch/powerpc/kernel/head_64.S
index b7d140430a41..831acbdf2592 100644
--- a/arch/powerpc/kernel/head_64.S
+++ b/arch/powerpc/kernel/head_64.S
@@ -316,6 +316,21 @@ label##_pSeries:					\
         mtspr   SPRN_SPRG1,r13;         /* save r13 */  \
         EXCEPTION_PROLOG_PSERIES(PACA_EXGEN, label##_common)
 
+#define HSTD_EXCEPTION_PSERIES(n, label)                \
+        . = n;                                          \
+        .globl label##_pSeries;                         \
+label##_pSeries:                                        \
+        HMT_MEDIUM;                                     \
+        mtspr   SPRN_SPRG1,r20;         /* save r20 */  \
+        mfspr   r20,SPRN_HSRR0;         /* copy HSRR0 to SRR0 */ \
+        mtspr   SPRN_SRR0,r20;                          \
+        mfspr   r20,SPRN_HSRR1;         /* copy HSRR0 to SRR0 */ \
+        mtspr   SPRN_SRR1,r20;                          \
+        mfspr   r20,SPRN_SPRG1;         /* restore r20 */ \
+        mtspr   SPRN_SPRG1,r13;         /* save r13 */  \
+        EXCEPTION_PROLOG_PSERIES(PACA_EXGEN, label##_common)
+
+
 #define STD_EXCEPTION_ISERIES(n, label, area)           \
         .globl label##_iSeries;                         \
 label##_iSeries:                                        \
@@ -544,8 +559,17 @@ system_call_pSeries:
 
         STD_EXCEPTION_PSERIES(0xf20, altivec_unavailable)
 
+#ifdef CONFIG_CBE_RAS
+        HSTD_EXCEPTION_PSERIES(0x1200, cbe_system_error)
+#endif /* CONFIG_CBE_RAS */
         STD_EXCEPTION_PSERIES(0x1300, instruction_breakpoint)
+#ifdef CONFIG_CBE_RAS
+        HSTD_EXCEPTION_PSERIES(0x1600, cbe_maintenance)
+#endif /* CONFIG_CBE_RAS */
         STD_EXCEPTION_PSERIES(0x1700, altivec_assist)
+#ifdef CONFIG_CBE_RAS
+        HSTD_EXCEPTION_PSERIES(0x1800, cbe_thermal)
+#endif /* CONFIG_CBE_RAS */
 
         . = 0x3000
 
@@ -827,6 +851,11 @@ machine_check_common:
 #else
         STD_EXCEPTION_COMMON(0x1700, altivec_assist, .unknown_exception)
 #endif
+#ifdef CONFIG_CBE_RAS
+        STD_EXCEPTION_COMMON(0x1200, cbe_system_error, .cbe_system_error_exception)
+        STD_EXCEPTION_COMMON(0x1600, cbe_maintenance, .cbe_maintenance_exception)
+        STD_EXCEPTION_COMMON(0x1800, cbe_thermal, .cbe_thermal_exception)
+#endif /* CONFIG_CBE_RAS */
 
 /*
  * Here we have detected that the kernel stack pointer is bad.
diff --git a/arch/powerpc/kernel/iomap.c b/arch/powerpc/kernel/iomap.c
index fd8214caedee..a13a93dfc655 100644
--- a/arch/powerpc/kernel/iomap.c
+++ b/arch/powerpc/kernel/iomap.c
@@ -106,8 +106,6 @@ EXPORT_SYMBOL(iowrite32_rep);
 
 void __iomem *ioport_map(unsigned long port, unsigned int len)
 {
-        if (!_IO_IS_VALID(port))
-                return NULL;
         return (void __iomem *) (port+pci_io_base);
 }
 
diff --git a/arch/powerpc/kernel/iommu.c b/arch/powerpc/kernel/iommu.c
index 4eba60a32890..7cb77c20fc5d 100644
--- a/arch/powerpc/kernel/iommu.c
+++ b/arch/powerpc/kernel/iommu.c
@@ -418,10 +418,11 @@ void iommu_unmap_sg(struct iommu_table *tbl, struct scatterlist *sglist,
  * Build a iommu_table structure.  This contains a bit map which
  * is used to manage allocation of the tce space.
  */
-struct iommu_table *iommu_init_table(struct iommu_table *tbl)
+struct iommu_table *iommu_init_table(struct iommu_table *tbl, int nid)
 {
         unsigned long sz;
         static int welcomed = 0;
+        struct page *page;
 
         /* Set aside 1/4 of the table for large allocations. */
         tbl->it_halfpoint = tbl->it_size * 3 / 4;
@@ -429,10 +430,10 @@ struct iommu_table *iommu_init_table(struct iommu_table *tbl)
         /* number of bytes needed for the bitmap */
         sz = (tbl->it_size + 7) >> 3;
 
-        tbl->it_map = (unsigned long *)__get_free_pages(GFP_ATOMIC, get_order(sz));
-        if (!tbl->it_map)
+        page = alloc_pages_node(nid, GFP_ATOMIC, get_order(sz));
+        if (!page)
                 panic("iommu_init_table: Can't allocate %ld bytes\n", sz);
-
+        tbl->it_map = page_address(page);
         memset(tbl->it_map, 0, sz);
 
         tbl->it_hint = 0;
@@ -536,11 +537,12 @@ void iommu_unmap_single(struct iommu_table *tbl, dma_addr_t dma_handle,
  * to the dma address (mapping) of the first page.
  */
 void *iommu_alloc_coherent(struct iommu_table *tbl, size_t size,
-                dma_addr_t *dma_handle, unsigned long mask, gfp_t flag)
+                dma_addr_t *dma_handle, unsigned long mask, gfp_t flag, int node)
 {
         void *ret = NULL;
         dma_addr_t mapping;
         unsigned int npages, order;
+        struct page *page;
 
         size = PAGE_ALIGN(size);
         npages = size >> PAGE_SHIFT;
@@ -560,9 +562,10 @@ void *iommu_alloc_coherent(struct iommu_table *tbl, size_t size,
                 return NULL;
 
         /* Alloc enough pages (and possibly more) */
-        ret = (void *)__get_free_pages(flag, order);
-        if (!ret)
+        page = alloc_pages_node(node, flag, order);
+        if (!page)
                 return NULL;
+        ret = page_address(page);
         memset(ret, 0, size);
 
         /* Set up tces to cover the allocated range */
@@ -570,9 +573,9 @@ void *iommu_alloc_coherent(struct iommu_table *tbl, size_t size,
                               mask >> PAGE_SHIFT, order);
         if (mapping == DMA_ERROR_CODE) {
                 free_pages((unsigned long)ret, order);
-                ret = NULL;
-        } else
-                *dma_handle = mapping;
+                return NULL;
+        }
+        *dma_handle = mapping;
         return ret;
 }
 
diff --git a/arch/powerpc/kernel/irq.c b/arch/powerpc/kernel/irq.c
index 57d560c68897..40d4c14fde8f 100644
--- a/arch/powerpc/kernel/irq.c
+++ b/arch/powerpc/kernel/irq.c
@@ -47,6 +47,7 @@
 #include <linux/cpumask.h>
 #include <linux/profile.h>
 #include <linux/bitops.h>
+#include <linux/pci.h>
 
 #include <asm/uaccess.h>
 #include <asm/system.h>
@@ -379,8 +380,8 @@ unsigned int real_irq_to_virt_slowpath(unsigned int real_irq)
 #endif /* CONFIG_PPC64 */
 
 #ifdef CONFIG_IRQSTACKS
-struct thread_info *softirq_ctx[NR_CPUS];
-struct thread_info *hardirq_ctx[NR_CPUS];
+struct thread_info *softirq_ctx[NR_CPUS] __read_mostly;
+struct thread_info *hardirq_ctx[NR_CPUS] __read_mostly;
 
 void irq_ctx_init(void)
 {
@@ -436,6 +437,30 @@ void do_softirq(void)
 }
 EXPORT_SYMBOL(do_softirq);
 
+#ifdef CONFIG_PCI_MSI
+int pci_enable_msi(struct pci_dev * pdev)
+{
+        if (ppc_md.enable_msi)
+                return ppc_md.enable_msi(pdev);
+        else
+                return -1;
+}
+
+void pci_disable_msi(struct pci_dev * pdev)
+{
+        if (ppc_md.disable_msi)
+                ppc_md.disable_msi(pdev);
+}
+
+void pci_scan_msi_device(struct pci_dev *dev) {}
+int pci_enable_msix(struct pci_dev* dev, struct msix_entry *entries, int nvec) {return -1;}
+void pci_disable_msix(struct pci_dev *dev) {}
+void msi_remove_pci_irq_vectors(struct pci_dev *dev) {}
+void disable_msi_mode(struct pci_dev *dev, int pos, int type) {}
+void pci_no_msi(void) {}
+
+#endif
+
 #ifdef CONFIG_PPC64
 static int __init setup_noirqdistrib(char *str)
 {
diff --git a/arch/powerpc/kernel/lparcfg.c b/arch/powerpc/kernel/lparcfg.c
index 2cbde865d4f5..c02deaab26c7 100644
--- a/arch/powerpc/kernel/lparcfg.c
+++ b/arch/powerpc/kernel/lparcfg.c
@@ -521,10 +521,10 @@ static ssize_t lparcfg_write(struct file *file, const char __user * buf,
 
         current_weight = (resource >> 5 * 8) & 0xFF;
 
-        pr_debug("%s: current_entitled = %lu, current_weight = %lu\n",
+        pr_debug("%s: current_entitled = %lu, current_weight = %u\n",
                  __FUNCTION__, current_entitled, current_weight);
 
-        pr_debug("%s: new_entitled = %lu, new_weight = %lu\n",
+        pr_debug("%s: new_entitled = %lu, new_weight = %u\n",
                  __FUNCTION__, *new_entitled_ptr, *new_weight_ptr);
 
         retval = plpar_hcall_norets(H_SET_PPP, *new_entitled_ptr,
diff --git a/arch/powerpc/kernel/machine_kexec_64.c b/arch/powerpc/kernel/machine_kexec_64.c
index ee166c586642..a8fa04ef27cd 100644
--- a/arch/powerpc/kernel/machine_kexec_64.c
+++ b/arch/powerpc/kernel/machine_kexec_64.c
@@ -21,6 +21,7 @@
 #include <asm/machdep.h>
 #include <asm/cacheflush.h>
 #include <asm/paca.h>
+#include <asm/lmb.h>
 #include <asm/mmu.h>
 #include <asm/sections.h>       /* _end */
 #include <asm/prom.h>
@@ -335,7 +336,105 @@ static void __init export_htab_values(void)
         of_node_put(node);
 }
 
+static struct property crashk_base_prop = {
+        .name = "linux,crashkernel-base",
+        .length = sizeof(unsigned long),
+        .value = (unsigned char *)&crashk_res.start,
+};
+
+static unsigned long crashk_size;
+
+static struct property crashk_size_prop = {
+        .name = "linux,crashkernel-size",
+        .length = sizeof(unsigned long),
+        .value = (unsigned char *)&crashk_size,
+};
+
+static void __init export_crashk_values(void)
+{
+        struct device_node *node;
+        struct property *prop;
+
+        node = of_find_node_by_path("/chosen");
+        if (!node)
+                return;
+
+        /* There might be existing crash kernel properties, but we can't
+         * be sure what's in them, so remove them. */
+        prop = of_find_property(node, "linux,crashkernel-base", NULL);
+        if (prop)
+                prom_remove_property(node, prop);
+
+        prop = of_find_property(node, "linux,crashkernel-size", NULL);
+        if (prop)
+                prom_remove_property(node, prop);
+
+        if (crashk_res.start != 0) {
+                prom_add_property(node, &crashk_base_prop);
+                crashk_size = crashk_res.end - crashk_res.start + 1;
+                prom_add_property(node, &crashk_size_prop);
+        }
+
+        of_node_put(node);
+}
+
 void __init kexec_setup(void)
 {
         export_htab_values();
+        export_crashk_values();
+}
+
+static int __init early_parse_crashk(char *p)
+{
+        unsigned long size;
+
+        if (!p)
+                return 1;
+
+        size = memparse(p, &p);
+
+        if (*p == '@')
+                crashk_res.start = memparse(p + 1, &p);
+        else
+                crashk_res.start = KDUMP_KERNELBASE;
+
+        crashk_res.end = crashk_res.start + size - 1;
+
+        return 0;
+}
+early_param("crashkernel", early_parse_crashk);
+
+void __init reserve_crashkernel(void)
+{
+        unsigned long size;
+
+        if (crashk_res.start == 0)
+                return;
+
+        /* We might have got these values via the command line or the
+         * device tree, either way sanitise them now. */
+
+        size = crashk_res.end - crashk_res.start + 1;
+
+        if (crashk_res.start != KDUMP_KERNELBASE)
+                printk("Crash kernel location must be 0x%x\n",
+                                KDUMP_KERNELBASE);
+
+        crashk_res.start = KDUMP_KERNELBASE;
+        size = PAGE_ALIGN(size);
+        crashk_res.end = crashk_res.start + size - 1;
+
+        /* Crash kernel trumps memory limit */
+        if (memory_limit && memory_limit <= crashk_res.end) {
+                memory_limit = crashk_res.end + 1;
+                printk("Adjusted memory limit for crashkernel, now 0x%lx\n",
+                                memory_limit);
+        }
+
+        lmb_reserve(crashk_res.start, size);
+}
+
+int overlaps_crashkernel(unsigned long start, unsigned long size)
+{
+        return (start + size) > crashk_res.start && start <= crashk_res.end;
 }
diff --git a/arch/powerpc/kernel/misc_32.S b/arch/powerpc/kernel/misc_32.S
index be982023409e..01d3916c4cb1 100644
--- a/arch/powerpc/kernel/misc_32.S
+++ b/arch/powerpc/kernel/misc_32.S
@@ -216,7 +216,7 @@ _GLOBAL(call_setup_cpu)
         lwz     r4,0(r4)
         add     r4,r4,r3
         lwz     r5,CPU_SPEC_SETUP(r4)
-        cmpi    0,r5,0
+        cmpwi   0,r5,0
         add     r5,r5,r3
         beqlr
         mtctr   r5
diff --git a/arch/powerpc/kernel/misc_64.S b/arch/powerpc/kernel/misc_64.S
index 2778cce058e2..e8883d42c43c 100644
--- a/arch/powerpc/kernel/misc_64.S
+++ b/arch/powerpc/kernel/misc_64.S
@@ -482,7 +482,9 @@ _GLOBAL(identify_cpu)
         sub     r0,r3,r5
         std     r0,0(r4)
         ld      r4,CPU_SPEC_SETUP(r3)
+        cmpdi   0,r4,0
         add     r4,r4,r5
+        beqlr
         ld      r4,0(r4)
         add     r4,r4,r5
         mtctr   r4
@@ -768,9 +770,6 @@ _GLOBAL(giveup_altivec)
 
 #endif /* CONFIG_ALTIVEC */
 
-_GLOBAL(__setup_cpu_power3)
-        blr
-
 _GLOBAL(execve)
         li      r0,__NR_execve
         sc
diff --git a/arch/powerpc/kernel/nvram_64.c b/arch/powerpc/kernel/nvram_64.c
index ada50aa5b600..6960f090991e 100644
--- a/arch/powerpc/kernel/nvram_64.c
+++ b/arch/powerpc/kernel/nvram_64.c
@@ -204,7 +204,7 @@ static void nvram_print_partitions(char * label)
         printk(KERN_WARNING "indx\t\tsig\tchks\tlen\tname\n");
         list_for_each(p, &nvram_part->partition) {
                 tmp_part = list_entry(p, struct nvram_partition, partition);
-                printk(KERN_WARNING "%d    \t%02x\t%02x\t%d\t%s\n",
+                printk(KERN_WARNING "%4d    \t%02x\t%02x\t%d\t%s\n",
                        tmp_part->index, tmp_part->header.signature,
                        tmp_part->header.checksum, tmp_part->header.length,
                        tmp_part->header.name);
diff --git a/arch/powerpc/kernel/pci_32.c b/arch/powerpc/kernel/pci_32.c
index b129d2e4b759..c858eb4bef17 100644
--- a/arch/powerpc/kernel/pci_32.c
+++ b/arch/powerpc/kernel/pci_32.c
@@ -1113,9 +1113,10 @@ check_for_io_childs(struct pci_bus *bus, struct resource* res, int *found_vga)
         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)
+#define push_end(res, mask) do {                \
+        BUG_ON((mask+1) & mask);                \
+        res->end = (res->end + mask) | mask;    \
+} while (0)
 
         list_for_each_entry(dev, &bus->devices, bus_list) {
                 u16 class = dev->class >> 8;
diff --git a/arch/powerpc/kernel/pci_64.c b/arch/powerpc/kernel/pci_64.c
index 4c4449be81ce..5ad87c426bed 100644
--- a/arch/powerpc/kernel/pci_64.c
+++ b/arch/powerpc/kernel/pci_64.c
@@ -42,14 +42,6 @@
 unsigned long pci_probe_only = 1;
 int pci_assign_all_buses = 0;
 
-/*
- * legal IO pages under MAX_ISA_PORT.  This is to ensure we don't touch
- * devices we don't have access to.
- */
-unsigned long io_page_mask;
-
-EXPORT_SYMBOL(io_page_mask);
-
 #ifdef CONFIG_PPC_MULTIPLATFORM
 static void fixup_resource(struct resource *res, struct pci_dev *dev);
 static void do_bus_setup(struct pci_bus *bus);
@@ -235,8 +227,10 @@ struct pci_controller * pcibios_alloc_controller(struct device_node *dev)
         pci_setup_pci_controller(phb);
         phb->arch_data = dev;
         phb->is_dynamic = mem_init_done;
-        if (dev)
+        if (dev) {
+                PHB_SET_NODE(phb, of_node_to_nid(dev));
                 add_linux_pci_domain(dev, phb);
+        }
         return phb;
 }
 
@@ -396,7 +390,7 @@ struct pci_dev *of_create_pci_dev(struct device_node *node,
 
         dev->current_state = 4;         /* unknown power state */
 
-        if (!strcmp(type, "pci")) {
+        if (!strcmp(type, "pci") || !strcmp(type, "pciex")) {
                 /* a PCI-PCI bridge */
                 dev->hdr_type = PCI_HEADER_TYPE_BRIDGE;
                 dev->rom_base_reg = PCI_ROM_ADDRESS1;
@@ -605,7 +599,7 @@ static int __init pcibios_init(void)
         iSeries_pcibios_init(); 
 #endif
 
-        printk("PCI: Probing PCI hardware\n");
+        printk(KERN_DEBUG "PCI: Probing PCI hardware\n");
 
         /* Scan all of the recorded PCI controllers.  */
         list_for_each_entry_safe(hose, tmp, &hose_list, list_node) {
@@ -630,14 +624,14 @@ static int __init pcibios_init(void)
         /* Cache the location of the ISA bridge (if we have one) */
         ppc64_isabridge_dev = pci_get_class(PCI_CLASS_BRIDGE_ISA << 8, NULL);
         if (ppc64_isabridge_dev != NULL)
-                printk("ISA bridge at %s\n", pci_name(ppc64_isabridge_dev));
+                printk(KERN_DEBUG "ISA bridge at %s\n", pci_name(ppc64_isabridge_dev));
 
 #ifdef CONFIG_PPC_MULTIPLATFORM
         /* map in PCI I/O space */
         phbs_remap_io();
 #endif
 
-        printk("PCI: Probing PCI hardware done\n");
+        printk(KERN_DEBUG "PCI: Probing PCI hardware done\n");
 
         return 0;
 }
@@ -804,7 +798,7 @@ static pgprot_t __pci_mmap_set_pgprot(struct pci_dev *dev, struct resource *rp,
         else
                 prot |= _PAGE_GUARDED;
 
-        printk("PCI map for %s:%lx, prot: %lx\n", pci_name(dev), rp->start,
+        printk(KERN_DEBUG "PCI map for %s:%lx, prot: %lx\n", pci_name(dev), rp->start,
                prot);
 
         return __pgprot(prot);
@@ -894,8 +888,8 @@ int pci_mmap_page_range(struct pci_dev *dev, struct vm_area_struct *vma,
         return ret;
 }
 
-#ifdef CONFIG_PPC_MULTIPLATFORM
-static ssize_t pci_show_devspec(struct device *dev, struct device_attribute *attr, char *buf)
+static ssize_t pci_show_devspec(struct device *dev,
+                struct device_attribute *attr, char *buf)
 {
         struct pci_dev *pdev;
         struct device_node *np;
@@ -907,13 +901,10 @@ static ssize_t pci_show_devspec(struct device *dev, struct device_attribute *att
         return sprintf(buf, "%s", np->full_name);
 }
 static DEVICE_ATTR(devspec, S_IRUGO, pci_show_devspec, NULL);
-#endif /* CONFIG_PPC_MULTIPLATFORM */
 
 void pcibios_add_platform_entries(struct pci_dev *pdev)
 {
-#ifdef CONFIG_PPC_MULTIPLATFORM
         device_create_file(&pdev->dev, &dev_attr_devspec);
-#endif /* CONFIG_PPC_MULTIPLATFORM */
 }
 
 #ifdef CONFIG_PPC_MULTIPLATFORM
@@ -1104,8 +1095,6 @@ void __init pci_setup_phb_io(struct pci_controller *hose, int primary)
                         pci_process_ISA_OF_ranges(isa_dn, hose->io_base_phys,
                                                 hose->io_base_virt);
                         of_node_put(isa_dn);
-                        /* Allow all IO */
-                        io_page_mask = -1;
                 }
         }
 
@@ -1212,7 +1201,7 @@ int remap_bus_range(struct pci_bus *bus)
                 return 1;
         if (start_phys == 0)
                 return 1;
-        printk("mapping IO %lx -> %lx, size: %lx\n", start_phys, start_virt, size);
+        printk(KERN_DEBUG "mapping IO %lx -> %lx, size: %lx\n", start_phys, start_virt, size);
         if (__ioremap_explicit(start_phys, start_virt, size,
                                _PAGE_NO_CACHE | _PAGE_GUARDED))
                 return 1;
@@ -1232,27 +1221,13 @@ static void phbs_remap_io(void)
 static void __devinit fixup_resource(struct resource *res, struct pci_dev *dev)
 {
         struct pci_controller *hose = pci_bus_to_host(dev->bus);
-        unsigned long start, end, mask, offset;
+        unsigned long offset;
 
         if (res->flags & IORESOURCE_IO) {
                 offset = (unsigned long)hose->io_base_virt - pci_io_base;
 
-                start = res->start += offset;
-                end = res->end += offset;
-
-                /* Need to allow IO access to pages that are in the
-                   ISA range */
-                if (start < MAX_ISA_PORT) {
-                        if (end > MAX_ISA_PORT)
-                                end = MAX_ISA_PORT;
-
-                        start >>= PAGE_SHIFT;
-                        end >>= PAGE_SHIFT;
-
-                        /* get the range of pages for the map */
-                        mask = ((1 << (end+1)) - 1) ^ ((1 << start) - 1);
-                        io_page_mask |= mask;
-                }
+                res->start += offset;
+                res->end += offset;
         } else if (res->flags & IORESOURCE_MEM) {
                 res->start += hose->pci_mem_offset;
                 res->end += hose->pci_mem_offset;
@@ -1442,3 +1417,12 @@ long sys_pciconfig_iobase(long which, unsigned long in_bus,
 
         return -EOPNOTSUPP;
 }
+
+#ifdef CONFIG_NUMA
+int pcibus_to_node(struct pci_bus *bus)
+{
+        struct pci_controller *phb = pci_bus_to_host(bus);
+        return phb->node;
+}
+EXPORT_SYMBOL(pcibus_to_node);
+#endif
diff --git a/arch/powerpc/kernel/pci_direct_iommu.c b/arch/powerpc/kernel/pci_direct_iommu.c
index e1a32f802c0b..72ce082ce738 100644
--- a/arch/powerpc/kernel/pci_direct_iommu.c
+++ b/arch/powerpc/kernel/pci_direct_iommu.c
@@ -82,13 +82,17 @@ static int pci_direct_dma_supported(struct device *dev, u64 mask)
         return mask < 0x100000000ull;
 }
 
+static struct dma_mapping_ops pci_direct_ops = {
+        .alloc_coherent = pci_direct_alloc_coherent,
+        .free_coherent = pci_direct_free_coherent,
+        .map_single = pci_direct_map_single,
+        .unmap_single = pci_direct_unmap_single,
+        .map_sg = pci_direct_map_sg,
+        .unmap_sg = pci_direct_unmap_sg,
+        .dma_supported = pci_direct_dma_supported,
+};
+
 void __init pci_direct_iommu_init(void)
 {
-        pci_dma_ops.alloc_coherent = pci_direct_alloc_coherent;
-        pci_dma_ops.free_coherent = pci_direct_free_coherent;
-        pci_dma_ops.map_single = pci_direct_map_single;
-        pci_dma_ops.unmap_single = pci_direct_unmap_single;
-        pci_dma_ops.map_sg = pci_direct_map_sg;
-        pci_dma_ops.unmap_sg = pci_direct_unmap_sg;
-        pci_dma_ops.dma_supported = pci_direct_dma_supported;
+        pci_dma_ops = pci_direct_ops;
 }
diff --git a/arch/powerpc/kernel/pci_dn.c b/arch/powerpc/kernel/pci_dn.c
index 12c4c9e9bbc7..1c18953514c3 100644
--- a/arch/powerpc/kernel/pci_dn.c
+++ b/arch/powerpc/kernel/pci_dn.c
@@ -31,6 +31,7 @@
 #include <asm/pci-bridge.h>
 #include <asm/pSeries_reconfig.h>
 #include <asm/ppc-pci.h>
+#include <asm/firmware.h>
 
 /*
  * Traverse_func that inits the PCI fields of the device node.
@@ -59,6 +60,11 @@ static void * __devinit update_dn_pci_info(struct device_node *dn, void *data)
                 pdn->busno = (regs[0] >> 16) & 0xff;
                 pdn->devfn = (regs[0] >> 8) & 0xff;
         }
+        if (firmware_has_feature(FW_FEATURE_ISERIES)) {
+                u32 *busp = (u32 *)get_property(dn, "linux,subbus", NULL);
+                if (busp)
+                        pdn->bussubno = *busp;
+        }
 
         pdn->pci_ext_config_space = (type && *type == 1);
         return NULL;
diff --git a/arch/powerpc/kernel/pci_iommu.c b/arch/powerpc/kernel/pci_iommu.c
index c1d95e14bbed..0688b2534acb 100644
--- a/arch/powerpc/kernel/pci_iommu.c
+++ b/arch/powerpc/kernel/pci_iommu.c
@@ -44,16 +44,16 @@
  */
 #define PCI_GET_DN(dev) ((struct device_node *)((dev)->sysdata))
 
-static inline struct iommu_table *devnode_table(struct device *dev)
+static inline struct iommu_table *device_to_table(struct device *hwdev)
 {
         struct pci_dev *pdev;
 
-        if (!dev) {
+        if (!hwdev) {
                 pdev = ppc64_isabridge_dev;
                 if (!pdev)
                         return NULL;
         } else
-                pdev = to_pci_dev(dev);
+                pdev = to_pci_dev(hwdev);
 
         return PCI_DN(PCI_GET_DN(pdev))->iommu_table;
 }
@@ -85,14 +85,15 @@ static inline unsigned long device_to_mask(struct device *hwdev)
 static void *pci_iommu_alloc_coherent(struct device *hwdev, size_t size,
                            dma_addr_t *dma_handle, gfp_t flag)
 {
-        return iommu_alloc_coherent(devnode_table(hwdev), size, dma_handle,
-                        device_to_mask(hwdev), flag);
+        return iommu_alloc_coherent(device_to_table(hwdev), size, dma_handle,
+                        device_to_mask(hwdev), flag,
+                        pcibus_to_node(to_pci_dev(hwdev)->bus));
 }
 
 static void pci_iommu_free_coherent(struct device *hwdev, size_t size,
                          void *vaddr, dma_addr_t dma_handle)
 {
-        iommu_free_coherent(devnode_table(hwdev), size, vaddr, dma_handle);
+        iommu_free_coherent(device_to_table(hwdev), size, vaddr, dma_handle);
 }
 
 /* Creates TCEs for a user provided buffer.  The user buffer must be 
@@ -104,7 +105,7 @@ static void pci_iommu_free_coherent(struct device *hwdev, size_t size,
 static dma_addr_t pci_iommu_map_single(struct device *hwdev, void *vaddr,
                 size_t size, enum dma_data_direction direction)
 {
-        return iommu_map_single(devnode_table(hwdev), vaddr, size,
+        return iommu_map_single(device_to_table(hwdev), vaddr, size,
                                 device_to_mask(hwdev), direction);
 }
 
@@ -112,27 +113,27 @@ static dma_addr_t pci_iommu_map_single(struct device *hwdev, void *vaddr,
 static void pci_iommu_unmap_single(struct device *hwdev, dma_addr_t dma_handle,
                 size_t size, enum dma_data_direction direction)
 {
-        iommu_unmap_single(devnode_table(hwdev), dma_handle, size, direction);
+        iommu_unmap_single(device_to_table(hwdev), dma_handle, size, direction);
 }
 
 
 static int pci_iommu_map_sg(struct device *pdev, struct scatterlist *sglist,
                 int nelems, enum dma_data_direction direction)
 {
-        return iommu_map_sg(pdev, devnode_table(pdev), sglist,
+        return iommu_map_sg(pdev, device_to_table(pdev), sglist,
                         nelems, device_to_mask(pdev), direction);
 }
 
 static void pci_iommu_unmap_sg(struct device *pdev, struct scatterlist *sglist,
                 int nelems, enum dma_data_direction direction)
 {
-        iommu_unmap_sg(devnode_table(pdev), sglist, nelems, direction);
+        iommu_unmap_sg(device_to_table(pdev), sglist, nelems, direction);
 }
 
 /* We support DMA to/from any memory page via the iommu */
 static int pci_iommu_dma_supported(struct device *dev, u64 mask)
 {
-        struct iommu_table *tbl = devnode_table(dev);
+        struct iommu_table *tbl = device_to_table(dev);
 
         if (!tbl || tbl->it_offset > mask) {
                 printk(KERN_INFO "Warning: IOMMU table offset too big for device mask\n");
@@ -147,13 +148,17 @@ static int pci_iommu_dma_supported(struct device *dev, u64 mask)
                 return 1;
 }
 
+struct dma_mapping_ops pci_iommu_ops = {
+        .alloc_coherent = pci_iommu_alloc_coherent,
+        .free_coherent = pci_iommu_free_coherent,
+        .map_single = pci_iommu_map_single,
+        .unmap_single = pci_iommu_unmap_single,
+        .map_sg = pci_iommu_map_sg,
+        .unmap_sg = pci_iommu_unmap_sg,
+        .dma_supported = pci_iommu_dma_supported,
+};
+
 void pci_iommu_init(void)
 {
-        pci_dma_ops.alloc_coherent = pci_iommu_alloc_coherent;
-        pci_dma_ops.free_coherent = pci_iommu_free_coherent;
-        pci_dma_ops.map_single = pci_iommu_map_single;
-        pci_dma_ops.unmap_single = pci_iommu_unmap_single;
-        pci_dma_ops.map_sg = pci_iommu_map_sg;
-        pci_dma_ops.unmap_sg = pci_iommu_unmap_sg;
-        pci_dma_ops.dma_supported = pci_iommu_dma_supported;
+        pci_dma_ops = pci_iommu_ops;
 }
diff --git a/arch/powerpc/kernel/proc_ppc64.c b/arch/powerpc/kernel/proc_ppc64.c
index 3c2cf661f6d9..2b87f82df135 100644
--- a/arch/powerpc/kernel/proc_ppc64.c
+++ b/arch/powerpc/kernel/proc_ppc64.c
@@ -52,7 +52,7 @@ static int __init proc_ppc64_create(void)
         if (!root)
                 return 1;
 
-        if (!machine_is(pseries) && !machine_is(cell))
+        if (!of_find_node_by_path("/rtas"))
                 return 0;
 
         if (!proc_mkdir("rtas", root))
diff --git a/arch/powerpc/kernel/process.c b/arch/powerpc/kernel/process.c
index 2dd47d2dd998..e4732459c485 100644
--- a/arch/powerpc/kernel/process.c
+++ b/arch/powerpc/kernel/process.c
@@ -708,6 +708,61 @@ int get_fpexc_mode(struct task_struct *tsk, unsigned long adr)
         return put_user(val, (unsigned int __user *) adr);
 }
 
+int set_endian(struct task_struct *tsk, unsigned int val)
+{
+        struct pt_regs *regs = tsk->thread.regs;
+
+        if ((val == PR_ENDIAN_LITTLE && !cpu_has_feature(CPU_FTR_REAL_LE)) ||
+            (val == PR_ENDIAN_PPC_LITTLE && !cpu_has_feature(CPU_FTR_PPC_LE)))
+                return -EINVAL;
+
+        if (regs == NULL)
+                return -EINVAL;
+
+        if (val == PR_ENDIAN_BIG)
+                regs->msr &= ~MSR_LE;
+        else if (val == PR_ENDIAN_LITTLE || val == PR_ENDIAN_PPC_LITTLE)
+                regs->msr |= MSR_LE;
+        else
+                return -EINVAL;
+
+        return 0;
+}
+
+int get_endian(struct task_struct *tsk, unsigned long adr)
+{
+        struct pt_regs *regs = tsk->thread.regs;
+        unsigned int val;
+
+        if (!cpu_has_feature(CPU_FTR_PPC_LE) &&
+            !cpu_has_feature(CPU_FTR_REAL_LE))
+                return -EINVAL;
+
+        if (regs == NULL)
+                return -EINVAL;
+
+        if (regs->msr & MSR_LE) {
+                if (cpu_has_feature(CPU_FTR_REAL_LE))
+                        val = PR_ENDIAN_LITTLE;
+                else
+                        val = PR_ENDIAN_PPC_LITTLE;
+        } else
+                val = PR_ENDIAN_BIG;
+
+        return put_user(val, (unsigned int __user *)adr);
+}
+
+int set_unalign_ctl(struct task_struct *tsk, unsigned int val)
+{
+        tsk->thread.align_ctl = val;
+        return 0;
+}
+
+int get_unalign_ctl(struct task_struct *tsk, unsigned long adr)
+{
+        return put_user(tsk->thread.align_ctl, (unsigned int __user *)adr);
+}
+
 #define TRUNC_PTR(x)    ((typeof(x))(((unsigned long)(x)) & 0xffffffff))
 
 int sys_clone(unsigned long clone_flags, unsigned long usp,
diff --git a/arch/powerpc/kernel/prom.c b/arch/powerpc/kernel/prom.c
index 9a07f97f0712..483455c5bb02 100644
--- a/arch/powerpc/kernel/prom.c
+++ b/arch/powerpc/kernel/prom.c
@@ -50,6 +50,7 @@
 #include <asm/machdep.h>
 #include <asm/pSeries_reconfig.h>
 #include <asm/pci-bridge.h>
+#include <asm/kexec.h>
 
 #ifdef DEBUG
 #define DBG(fmt...) printk(KERN_ERR fmt)
@@ -836,6 +837,42 @@ static unsigned long __init unflatten_dt_node(unsigned long mem,
         return mem;
 }
 
+static int __init early_parse_mem(char *p)
+{
+        if (!p)
+                return 1;
+
+        memory_limit = PAGE_ALIGN(memparse(p, &p));
+        DBG("memory limit = 0x%lx\n", memory_limit);
+
+        return 0;
+}
+early_param("mem", early_parse_mem);
+
+/*
+ * The device tree may be allocated below our memory limit, or inside the
+ * crash kernel region for kdump. If so, move it out now.
+ */
+static void move_device_tree(void)
+{
+        unsigned long start, size;
+        void *p;
+
+        DBG("-> move_device_tree\n");
+
+        start = __pa(initial_boot_params);
+        size = initial_boot_params->totalsize;
+
+        if ((memory_limit && (start + size) > memory_limit) ||
+                        overlaps_crashkernel(start, size)) {
+                p = __va(lmb_alloc_base(size, PAGE_SIZE, lmb.rmo_size));
+                memcpy(p, initial_boot_params, size);
+                initial_boot_params = (struct boot_param_header *)p;
+                DBG("Moved device tree to 0x%p\n", p);
+        }
+
+        DBG("<- move_device_tree\n");
+}
 
 /**
  * unflattens the device-tree passed by the firmware, creating the
@@ -911,7 +948,10 @@ static struct ibm_pa_feature {
         {CPU_FTR_CTRL, 0,               0, 3, 0},
         {CPU_FTR_NOEXECUTE, 0,          0, 6, 0},
         {CPU_FTR_NODSISRALIGN, 0,       1, 1, 1},
+#if 0
+        /* put this back once we know how to test if firmware does 64k IO */
         {CPU_FTR_CI_LARGE_PAGE, 0,      1, 2, 0},
+#endif
 };
 
 static void __init check_cpu_pa_features(unsigned long node)
@@ -1070,6 +1110,7 @@ static int __init early_init_dt_scan_chosen(unsigned long node,
                 iommu_force_on = 1;
 #endif
 
+        /* mem=x on the command line is the preferred mechanism */
         lprop = of_get_flat_dt_prop(node, "linux,memory-limit", NULL);
         if (lprop)
                 memory_limit = *lprop;
@@ -1123,17 +1164,6 @@ static int __init early_init_dt_scan_chosen(unsigned long node,
 
         DBG("Command line is: %s\n", cmd_line);
 
-        if (strstr(cmd_line, "mem=")) {
-                char *p, *q;
-
-                for (q = cmd_line; (p = strstr(q, "mem=")) != 0; ) {
-                        q = p + 4;
-                        if (p > cmd_line && p[-1] != ' ')
-                                continue;
-                        memory_limit = memparse(q, &q);
-                }
-        }
-
         /* break now */
         return 1;
 }
@@ -1237,9 +1267,17 @@ static void __init early_reserve_mem(void)
 {
         u64 base, size;
         u64 *reserve_map;
+        unsigned long self_base;
+        unsigned long self_size;
 
         reserve_map = (u64 *)(((unsigned long)initial_boot_params) +
                                         initial_boot_params->off_mem_rsvmap);
+
+        /* before we do anything, lets reserve the dt blob */
+        self_base = __pa((unsigned long)initial_boot_params);
+        self_size = initial_boot_params->totalsize;
+        lmb_reserve(self_base, self_size);
+
 #ifdef CONFIG_PPC32
         /* 
          * Handle the case where we might be booting from an old kexec
@@ -1254,6 +1292,9 @@ static void __init early_reserve_mem(void)
                         size_32 = *(reserve_map_32++);
                         if (size_32 == 0)
                                 break;
+                        /* skip if the reservation is for the blob */
+                        if (base_32 == self_base && size_32 == self_size)
+                                continue;
                         DBG("reserving: %x -> %x\n", base_32, size_32);
                         lmb_reserve(base_32, size_32);
                 }
@@ -1265,6 +1306,9 @@ static void __init early_reserve_mem(void)
                 size = *(reserve_map++);
                 if (size == 0)
                         break;
+                /* skip if the reservation is for the blob */
+                if (base == self_base && size == self_size)
+                        continue;
                 DBG("reserving: %llx -> %llx\n", base, size);
                 lmb_reserve(base, size);
         }
@@ -1292,18 +1336,26 @@ void __init early_init_devtree(void *params)
         lmb_init();
         of_scan_flat_dt(early_init_dt_scan_root, NULL);
         of_scan_flat_dt(early_init_dt_scan_memory, NULL);
-        lmb_enforce_memory_limit(memory_limit);
-        lmb_analyze();
 
-        DBG("Phys. mem: %lx\n", lmb_phys_mem_size());
+        /* Save command line for /proc/cmdline and then parse parameters */
+        strlcpy(saved_command_line, cmd_line, COMMAND_LINE_SIZE);
+        parse_early_param();
 
         /* Reserve LMB regions used by kernel, initrd, dt, etc... */
         lmb_reserve(PHYSICAL_START, __pa(klimit) - PHYSICAL_START);
-#ifdef CONFIG_CRASH_DUMP
-        lmb_reserve(0, KDUMP_RESERVE_LIMIT);
-#endif
+        reserve_kdump_trampoline();
+        reserve_crashkernel();
         early_reserve_mem();
 
+        lmb_enforce_memory_limit(memory_limit);
+        lmb_analyze();
+
+        DBG("Phys. mem: %lx\n", lmb_phys_mem_size());
+
+        /* We may need to relocate the flat tree, do it now.
+         * FIXME .. and the initrd too? */
+        move_device_tree();
+
         DBG("Scanning CPUs ...\n");
 
         /* Retreive CPU related informations from the flat tree
@@ -2053,29 +2105,46 @@ int prom_update_property(struct device_node *np,
         return 0;
 }
 
-#ifdef CONFIG_KEXEC
-/* We may have allocated the flat device tree inside the crash kernel region
- * in prom_init. If so we need to move it out into regular memory. */
-void kdump_move_device_tree(void)
-{
-        unsigned long start, end;
-        struct boot_param_header *new;
-
-        start = __pa((unsigned long)initial_boot_params);
-        end = start + initial_boot_params->totalsize;
-
-        if (end < crashk_res.start || start > crashk_res.end)
-                return;
 
-        new = (struct boot_param_header*)
-                __va(lmb_alloc(initial_boot_params->totalsize, PAGE_SIZE));
-
-        memcpy(new, initial_boot_params, initial_boot_params->totalsize);
+/* Find the device node for a given logical cpu number, also returns the cpu
+ * local thread number (index in ibm,interrupt-server#s) if relevant and
+ * asked for (non NULL)
+ */
+struct device_node *of_get_cpu_node(int cpu, unsigned int *thread)
+{
+        int hardid;
+        struct device_node *np;
 
-        initial_boot_params = new;
+        hardid = get_hard_smp_processor_id(cpu);
 
-        DBG("Flat device tree blob moved to %p\n", initial_boot_params);
+        for_each_node_by_type(np, "cpu") {
+                u32 *intserv;
+                unsigned int plen, t;
 
-        /* XXX should we unreserve the old DT? */
+                /* Check for ibm,ppc-interrupt-server#s. If it doesn't exist
+                 * fallback to "reg" property and assume no threads
+                 */
+                intserv = (u32 *)get_property(np, "ibm,ppc-interrupt-server#s",
+                                              &plen);
+                if (intserv == NULL) {
+                        u32 *reg = (u32 *)get_property(np, "reg", NULL);
+                        if (reg == NULL)
+                                continue;
+                        if (*reg == hardid) {
+                                if (thread)
+                                        *thread = 0;
+                                return np;
+                        }
+                } else {
+                        plen /= sizeof(u32);
+                        for (t = 0; t < plen; t++) {
+                                if (hardid == intserv[t]) {
+                                        if (thread)
+                                                *thread = t;
+                                        return np;
+                                }
+                        }
+                }
+        }
+        return NULL;
 }
-#endif /* CONFIG_KEXEC */
diff --git a/arch/powerpc/kernel/prom_init.c b/arch/powerpc/kernel/prom_init.c
index f70bd090dacd..8c28eb0cbdac 100644
--- a/arch/powerpc/kernel/prom_init.c
+++ b/arch/powerpc/kernel/prom_init.c
@@ -194,19 +194,12 @@ static int __initdata of_platform;
 
 static char __initdata prom_cmd_line[COMMAND_LINE_SIZE];
 
-static unsigned long __initdata prom_memory_limit;
-
 static unsigned long __initdata alloc_top;
 static unsigned long __initdata alloc_top_high;
 static unsigned long __initdata alloc_bottom;
 static unsigned long __initdata rmo_top;
 static unsigned long __initdata ram_top;
 
-#ifdef CONFIG_KEXEC
-static unsigned long __initdata prom_crashk_base;
-static unsigned long __initdata prom_crashk_size;
-#endif
-
 static struct mem_map_entry __initdata mem_reserve_map[MEM_RESERVE_MAP_SIZE];
 static int __initdata mem_reserve_cnt;
 
@@ -574,7 +567,7 @@ static void __init early_cmdline_parse(void)
         if ((long)_prom->chosen > 0)
                 l = prom_getprop(_prom->chosen, "bootargs", p, COMMAND_LINE_SIZE-1);
 #ifdef CONFIG_CMDLINE
-        if (l == 0) /* dbl check */
+        if (l <= 0 || p[0] == '\0') /* dbl check */
                 strlcpy(RELOC(prom_cmd_line),
                         RELOC(CONFIG_CMDLINE), sizeof(prom_cmd_line));
 #endif /* CONFIG_CMDLINE */
@@ -593,45 +586,6 @@ static void __init early_cmdline_parse(void)
                         RELOC(iommu_force_on) = 1;
         }
 #endif
-
-        opt = strstr(RELOC(prom_cmd_line), RELOC("mem="));
-        if (opt) {
-                opt += 4;
-                RELOC(prom_memory_limit) = prom_memparse(opt, (const char **)&opt);
-#ifdef CONFIG_PPC64
-                /* Align to 16 MB == size of ppc64 large page */
-                RELOC(prom_memory_limit) = ALIGN(RELOC(prom_memory_limit), 0x1000000);
-#endif
-        }
-
-#ifdef CONFIG_KEXEC
-        /*
-         * crashkernel=size@addr specifies the location to reserve for
-         * crash kernel.
-         */
-        opt = strstr(RELOC(prom_cmd_line), RELOC("crashkernel="));
-        if (opt) {
-                opt += 12;
-                RELOC(prom_crashk_size) = 
-                        prom_memparse(opt, (const char **)&opt);
-
-                if (ALIGN(RELOC(prom_crashk_size), 0x1000000) !=
-                        RELOC(prom_crashk_size)) {
-                        prom_printf("Warning: crashkernel size is not "
-                                        "aligned to 16MB\n");
-                }
-
-                /*
-                 * At present, the crash kernel always run at 32MB.
-                 * Just ignore whatever user passed.
-                 */
-                RELOC(prom_crashk_base) = 0x2000000;
-                if (*opt == '@') {
-                        prom_printf("Warning: PPC64 kdump kernel always runs "
-                                        "at 32 MB\n");
-                }
-        }
-#endif
 }
 
 #ifdef CONFIG_PPC_PSERIES
@@ -1116,29 +1070,6 @@ static void __init prom_init_mem(void)
         }
 
         /*
-         * If prom_memory_limit is set we reduce the upper limits *except* for
-         * alloc_top_high. This must be the real top of RAM so we can put
-         * TCE's up there.
-         */
-
-        RELOC(alloc_top_high) = RELOC(ram_top);
-
-        if (RELOC(prom_memory_limit)) {
-                if (RELOC(prom_memory_limit) <= RELOC(alloc_bottom)) {
-                        prom_printf("Ignoring mem=%x <= alloc_bottom.\n",
-                                RELOC(prom_memory_limit));
-                        RELOC(prom_memory_limit) = 0;
-                } else if (RELOC(prom_memory_limit) >= RELOC(ram_top)) {
-                        prom_printf("Ignoring mem=%x >= ram_top.\n",
-                                RELOC(prom_memory_limit));
-                        RELOC(prom_memory_limit) = 0;
-                } else {
-                        RELOC(ram_top) = RELOC(prom_memory_limit);
-                        RELOC(rmo_top) = min(RELOC(rmo_top), RELOC(prom_memory_limit));
-                }
-        }
-
-        /*
          * Setup our top alloc point, that is top of RMO or top of
          * segment 0 when running non-LPAR.
          * Some RS64 machines have buggy firmware where claims up at
@@ -1150,20 +1081,14 @@ static void __init prom_init_mem(void)
                 RELOC(rmo_top) = RELOC(ram_top);
         RELOC(rmo_top) = min(0x30000000ul, RELOC(rmo_top));
         RELOC(alloc_top) = RELOC(rmo_top);
+        RELOC(alloc_top_high) = RELOC(ram_top);
 
         prom_printf("memory layout at init:\n");
-        prom_printf("  memory_limit : %x (16 MB aligned)\n", RELOC(prom_memory_limit));
         prom_printf("  alloc_bottom : %x\n", RELOC(alloc_bottom));
         prom_printf("  alloc_top    : %x\n", RELOC(alloc_top));
         prom_printf("  alloc_top_hi : %x\n", RELOC(alloc_top_high));
         prom_printf("  rmo_top      : %x\n", RELOC(rmo_top));
         prom_printf("  ram_top      : %x\n", RELOC(ram_top));
-#ifdef CONFIG_KEXEC
-        if (RELOC(prom_crashk_base)) {
-                prom_printf("  crashk_base  : %x\n",  RELOC(prom_crashk_base));
-                prom_printf("  crashk_size  : %x\n", RELOC(prom_crashk_size));
-        }
-#endif
 }
 
 
@@ -1349,16 +1274,10 @@ static void __init prom_initialize_tce_table(void)
 
         reserve_mem(local_alloc_bottom, local_alloc_top - local_alloc_bottom);
 
-        if (RELOC(prom_memory_limit)) {
-                /*
-                 * We align the start to a 16MB boundary so we can map
-                 * the TCE area using large pages if possible.
-                 * The end should be the top of RAM so no need to align it.
-                 */
-                RELOC(prom_tce_alloc_start) = _ALIGN_DOWN(local_alloc_bottom,
-                                                          0x1000000);
-                RELOC(prom_tce_alloc_end) = local_alloc_top;
-        }
+        /* These are only really needed if there is a memory limit in
+         * effect, but we don't know so export them always. */
+        RELOC(prom_tce_alloc_start) = local_alloc_bottom;
+        RELOC(prom_tce_alloc_end) = local_alloc_top;
 
         /* Flag the first invalid entry */
         prom_debug("ending prom_initialize_tce_table\n");
@@ -2041,11 +1960,7 @@ static void __init flatten_device_tree(void)
         /* Version 16 is not backward compatible */
         hdr->last_comp_version = 0x10;
 
-        /* Reserve the whole thing and copy the reserve map in, we
-         * also bump mem_reserve_cnt to cause further reservations to
-         * fail since it's too late.
-         */
-        reserve_mem(RELOC(dt_header_start), hdr->totalsize);
+        /* Copy the reserve map in */
         memcpy(rsvmap, RELOC(mem_reserve_map), sizeof(mem_reserve_map));
 
 #ifdef DEBUG_PROM
@@ -2058,6 +1973,9 @@ static void __init flatten_device_tree(void)
                                     RELOC(mem_reserve_map)[i].size);
         }
 #endif
+        /* Bump mem_reserve_cnt to cause further reservations to fail
+         * since it's too late.
+         */
         RELOC(mem_reserve_cnt) = MEM_RESERVE_MAP_SIZE;
 
         prom_printf("Device tree strings 0x%x -> 0x%x\n",
@@ -2280,10 +2198,6 @@ unsigned long __init prom_init(unsigned long r3, unsigned long r4,
          */
         prom_init_mem();
 
-#ifdef CONFIG_KEXEC
-        if (RELOC(prom_crashk_base))
-                reserve_mem(RELOC(prom_crashk_base), RELOC(prom_crashk_size));
-#endif
         /*
          * Determine which cpu is actually running right _now_
          */
@@ -2317,10 +2231,6 @@ unsigned long __init prom_init(unsigned long r3, unsigned long r4,
         /*
          * Fill in some infos for use by the kernel later on
          */
-        if (RELOC(prom_memory_limit))
-                prom_setprop(_prom->chosen, "/chosen", "linux,memory-limit",
-                             &RELOC(prom_memory_limit),
-                             sizeof(prom_memory_limit));
 #ifdef CONFIG_PPC64
         if (RELOC(ppc64_iommu_off))
                 prom_setprop(_prom->chosen, "/chosen", "linux,iommu-off",
@@ -2340,16 +2250,6 @@ unsigned long __init prom_init(unsigned long r3, unsigned long r4,
         }
 #endif
 
-#ifdef CONFIG_KEXEC
-        if (RELOC(prom_crashk_base)) {
-                prom_setprop(_prom->chosen, "/chosen", "linux,crashkernel-base",
-                        PTRRELOC(&prom_crashk_base),
-                        sizeof(RELOC(prom_crashk_base)));
-                prom_setprop(_prom->chosen, "/chosen", "linux,crashkernel-size",
-                        PTRRELOC(&prom_crashk_size),
-                        sizeof(RELOC(prom_crashk_size)));
-        }
-#endif
         /*
          * Fixup any known bugs in the device-tree
          */
diff --git a/arch/powerpc/kernel/prom_parse.c b/arch/powerpc/kernel/prom_parse.c
index 3934c227549b..45df420383cc 100644
--- a/arch/powerpc/kernel/prom_parse.c
+++ b/arch/powerpc/kernel/prom_parse.c
@@ -548,3 +548,28 @@ int of_pci_address_to_resource(struct device_node *dev, int bar,
         return __of_address_to_resource(dev, addrp, size, flags, r);
 }
 EXPORT_SYMBOL_GPL(of_pci_address_to_resource);
+
+void of_parse_dma_window(struct device_node *dn, unsigned char *dma_window_prop,
+                unsigned long *busno, unsigned long *phys, unsigned long *size)
+{
+        u32 *dma_window, cells;
+        unsigned char *prop;
+
+        dma_window = (u32 *)dma_window_prop;
+
+        /* busno is always one cell */
+        *busno = *(dma_window++);
+
+        prop = get_property(dn, "ibm,#dma-address-cells", NULL);
+        if (!prop)
+                prop = get_property(dn, "#address-cells", NULL);
+
+        cells = prop ? *(u32 *)prop : prom_n_addr_cells(dn);
+        *phys = of_read_addr(dma_window, cells);
+
+        dma_window += cells;
+
+        prop = get_property(dn, "ibm,#dma-size-cells", NULL);
+        cells = prop ? *(u32 *)prop : prom_n_size_cells(dn);
+        *size = of_read_addr(dma_window, cells);
+}
diff --git a/arch/powerpc/kernel/ptrace.c b/arch/powerpc/kernel/ptrace.c
index 4a677d1bd4ef..5563e2e7d89c 100644
--- a/arch/powerpc/kernel/ptrace.c
+++ b/arch/powerpc/kernel/ptrace.c
@@ -404,7 +404,6 @@ long arch_ptrace(struct task_struct *child, long request, long addr, long data)
                 ret = ptrace_detach(child, data);
                 break;
 
-#ifdef CONFIG_PPC64
         case PPC_PTRACE_GETREGS: { /* Get GPRs 0 - 31. */
                 int i;
                 unsigned long *reg = &((unsigned long *)child->thread.regs)[0];
@@ -468,7 +467,6 @@ long arch_ptrace(struct task_struct *child, long request, long addr, long data)
                 }
                 break;
         }
-#endif /* CONFIG_PPC64 */
 
 #ifdef CONFIG_ALTIVEC
         case PTRACE_GETVRREGS:
diff --git a/arch/powerpc/kernel/rtas-rtc.c b/arch/powerpc/kernel/rtas-rtc.c
index 34d073fb6091..77578c093dda 100644
--- a/arch/powerpc/kernel/rtas-rtc.c
+++ b/arch/powerpc/kernel/rtas-rtc.c
@@ -14,19 +14,20 @@
 unsigned long __init rtas_get_boot_time(void)
 {
         int ret[8];
-        int error, wait_time;
+        int error;
+        unsigned int wait_time;
         u64 max_wait_tb;
 
         max_wait_tb = get_tb() + tb_ticks_per_usec * 1000 * MAX_RTC_WAIT;
         do {
                 error = rtas_call(rtas_token("get-time-of-day"), 0, 8, ret);
-                if (error == RTAS_CLOCK_BUSY || rtas_is_extended_busy(error)) {
-                        wait_time = rtas_extended_busy_delay_time(error);
+
+                wait_time = rtas_busy_delay_time(error);
+                if (wait_time) {
                         /* This is boot time so we spin. */
                         udelay(wait_time*1000);
-                        error = RTAS_CLOCK_BUSY;
                 }
-        } while (error == RTAS_CLOCK_BUSY && (get_tb() < max_wait_tb));
+        } while (wait_time && (get_tb() < max_wait_tb));
 
         if (error != 0 && printk_ratelimit()) {
                 printk(KERN_WARNING "error: reading the clock failed (%d)\n",
@@ -44,24 +45,25 @@ unsigned long __init rtas_get_boot_time(void)
 void rtas_get_rtc_time(struct rtc_time *rtc_tm)
 {
         int ret[8];
-        int error, wait_time;
+        int error;
+        unsigned int wait_time;
         u64 max_wait_tb;
 
         max_wait_tb = get_tb() + tb_ticks_per_usec * 1000 * MAX_RTC_WAIT;
         do {
                 error = rtas_call(rtas_token("get-time-of-day"), 0, 8, ret);
-                if (error == RTAS_CLOCK_BUSY || rtas_is_extended_busy(error)) {
+
+                wait_time = rtas_busy_delay_time(error);
+                if (wait_time) {
                         if (in_interrupt() && printk_ratelimit()) {
                                 memset(rtc_tm, 0, sizeof(struct rtc_time));
                                 printk(KERN_WARNING "error: reading clock"
                                        " would delay interrupt\n");
                                 return; /* delay not allowed */
                         }
-                        wait_time = rtas_extended_busy_delay_time(error);
                         msleep(wait_time);
-                        error = RTAS_CLOCK_BUSY;
                 }
-        } while (error == RTAS_CLOCK_BUSY && (get_tb() < max_wait_tb));
+        } while (wait_time && (get_tb() < max_wait_tb));
 
         if (error != 0 && printk_ratelimit()) {
                 printk(KERN_WARNING "error: reading the clock failed (%d)\n",
@@ -88,14 +90,14 @@ int rtas_set_rtc_time(struct rtc_time *tm)
                                   tm->tm_year + 1900, tm->tm_mon + 1,
                                   tm->tm_mday, tm->tm_hour, tm->tm_min,
                                   tm->tm_sec, 0);
-                if (error == RTAS_CLOCK_BUSY || rtas_is_extended_busy(error)) {
+
+                wait_time = rtas_busy_delay_time(error);
+                if (wait_time) {
                         if (in_interrupt())
                                 return 1;       /* probably decrementer */
-                        wait_time = rtas_extended_busy_delay_time(error);
                         msleep(wait_time);
-                        error = RTAS_CLOCK_BUSY;
                 }
-        } while (error == RTAS_CLOCK_BUSY && (get_tb() < max_wait_tb));
+        } while (wait_time && (get_tb() < max_wait_tb));
 
         if (error != 0 && printk_ratelimit())
                 printk(KERN_WARNING "error: setting the clock failed (%d)\n",
diff --git a/arch/powerpc/kernel/rtas.c b/arch/powerpc/kernel/rtas.c
index 0112318213ab..17dc79198515 100644
--- a/arch/powerpc/kernel/rtas.c
+++ b/arch/powerpc/kernel/rtas.c
@@ -370,24 +370,36 @@ int rtas_call(int token, int nargs, int nret, int *outputs, ...)
         return ret;
 }
 
-/* Given an RTAS status code of 990n compute the hinted delay of 10^n
- * (last digit) milliseconds.  For now we bound at n=5 (100 sec).
+/* For RTAS_BUSY (-2), delay for 1 millisecond.  For an extended busy status
+ * code of 990n, perform the hinted delay of 10^n (last digit) milliseconds.
  */
-unsigned int rtas_extended_busy_delay_time(int status)
+unsigned int rtas_busy_delay_time(int status)
 {
-        int order = status - 9900;
-        unsigned long ms;
+        int order;
+        unsigned int ms = 0;
+
+        if (status == RTAS_BUSY) {
+                ms = 1;
+        } else if (status >= 9900 && status <= 9905) {
+                order = status - 9900;
+                for (ms = 1; order > 0; order--)
+                        ms *= 10;
+        }
 
-        if (order < 0)
-                order = 0;      /* RTC depends on this for -2 clock busy */
-        else if (order > 5)
-                order = 5;      /* bound */
+        return ms;
+}
 
-        /* Use microseconds for reasonable accuracy */
-        for (ms = 1; order > 0; order--)
-                ms *= 10;
+/* For an RTAS busy status code, perform the hinted delay. */
+unsigned int rtas_busy_delay(int status)
+{
+        unsigned int ms;
 
-        return ms; 
+        might_sleep();
+        ms = rtas_busy_delay_time(status);
+        if (ms)
+                msleep(ms);
+
+        return ms;
 }
 
 int rtas_error_rc(int rtas_rc)
@@ -438,22 +450,14 @@ int rtas_get_power_level(int powerdomain, int *level)
 int rtas_set_power_level(int powerdomain, int level, int *setlevel)
 {
         int token = rtas_token("set-power-level");
-        unsigned int wait_time;
         int rc;
 
         if (token == RTAS_UNKNOWN_SERVICE)
                 return -ENOENT;
 
-        while (1) {
+        do {
                 rc = rtas_call(token, 2, 2, setlevel, powerdomain, level);
-                if (rc == RTAS_BUSY)
-                        udelay(1);
-                else if (rtas_is_extended_busy(rc)) {
-                        wait_time = rtas_extended_busy_delay_time(rc);
-                        udelay(wait_time * 1000);
-                } else
-                        break;
-        }
+        } while (rtas_busy_delay(rc));
 
         if (rc < 0)
                 return rtas_error_rc(rc);
@@ -463,22 +467,14 @@ int rtas_set_power_level(int powerdomain, int level, int *setlevel)
 int rtas_get_sensor(int sensor, int index, int *state)
 {
         int token = rtas_token("get-sensor-state");
-        unsigned int wait_time;
         int rc;
 
         if (token == RTAS_UNKNOWN_SERVICE)
                 return -ENOENT;
 
-        while (1) {
+        do {
                 rc = rtas_call(token, 2, 2, state, sensor, index);
-                if (rc == RTAS_BUSY)
-                        udelay(1);
-                else if (rtas_is_extended_busy(rc)) {
-                        wait_time = rtas_extended_busy_delay_time(rc);
-                        udelay(wait_time * 1000);
-                } else
-                        break;
-        }
+        } while (rtas_busy_delay(rc));
 
         if (rc < 0)
                 return rtas_error_rc(rc);
@@ -488,23 +484,14 @@ int rtas_get_sensor(int sensor, int index, int *state)
 int rtas_set_indicator(int indicator, int index, int new_value)
 {
         int token = rtas_token("set-indicator");
-        unsigned int wait_time;
         int rc;
 
         if (token == RTAS_UNKNOWN_SERVICE)
                 return -ENOENT;
 
-        while (1) {
+        do {
                 rc = rtas_call(token, 3, 1, NULL, indicator, index, new_value);
-                if (rc == RTAS_BUSY)
-                        udelay(1);
-                else if (rtas_is_extended_busy(rc)) {
-                        wait_time = rtas_extended_busy_delay_time(rc);
-                        udelay(wait_time * 1000);
-                }
-                else
-                        break;
-        }
+        } while (rtas_busy_delay(rc));
 
         if (rc < 0)
                 return rtas_error_rc(rc);
@@ -555,13 +542,11 @@ void rtas_os_term(char *str)
         do {
                 status = rtas_call(rtas_token("ibm,os-term"), 1, 1, NULL,
                                    __pa(rtas_os_term_buf));
+        } while (rtas_busy_delay(status));
 
-                if (status == RTAS_BUSY)
-                        udelay(1);
-                else if (status != 0)
-                        printk(KERN_EMERG "ibm,os-term call failed %d\n",
+        if (status != 0)
+                printk(KERN_EMERG "ibm,os-term call failed %d\n",
                                status);
-        } while (status == RTAS_BUSY);
 }
 
 static int ibm_suspend_me_token = RTAS_UNKNOWN_SERVICE;
@@ -608,9 +593,31 @@ out:
 static int rtas_ibm_suspend_me(struct rtas_args *args)
 {
         int i;
+        long state;
+        long rc;
+        unsigned long dummy;
 
         struct rtas_suspend_me_data data;
 
+        /* Make sure the state is valid */
+        rc = plpar_hcall(H_VASI_STATE,
+                         ((u64)args->args[0] << 32) | args->args[1],
+                         0, 0, 0,
+                         &state, &dummy, &dummy);
+
+        if (rc) {
+                printk(KERN_ERR "rtas_ibm_suspend_me: vasi_state returned %ld\n",rc);
+                return rc;
+        } else if (state == H_VASI_ENABLED) {
+                args->args[args->nargs] = RTAS_NOT_SUSPENDABLE;
+                return 0;
+        } else if (state != H_VASI_SUSPENDING) {
+                printk(KERN_ERR "rtas_ibm_suspend_me: vasi_state returned state %ld\n",
+                       state);
+                args->args[args->nargs] = -1;
+                return 0;
+        }
+
         data.waiting = 1;
         data.args = args;
 
@@ -789,7 +796,8 @@ EXPORT_SYMBOL(rtas_token);
 EXPORT_SYMBOL(rtas_call);
 EXPORT_SYMBOL(rtas_data_buf);
 EXPORT_SYMBOL(rtas_data_buf_lock);
-EXPORT_SYMBOL(rtas_extended_busy_delay_time);
+EXPORT_SYMBOL(rtas_busy_delay_time);
+EXPORT_SYMBOL(rtas_busy_delay);
 EXPORT_SYMBOL(rtas_get_sensor);
 EXPORT_SYMBOL(rtas_get_power_level);
 EXPORT_SYMBOL(rtas_set_power_level);
diff --git a/arch/powerpc/kernel/rtas_flash.c b/arch/powerpc/kernel/rtas_flash.c
index aaf384c3f04a..1442b63a75da 100644
--- a/arch/powerpc/kernel/rtas_flash.c
+++ b/arch/powerpc/kernel/rtas_flash.c
@@ -365,20 +365,12 @@ static int rtas_excl_release(struct inode *inode, struct file *file)
 
 static void manage_flash(struct rtas_manage_flash_t *args_buf)
 {
-        unsigned int wait_time;
         s32 rc;
 
-        while (1) {
+        do {
                 rc = rtas_call(rtas_token("ibm,manage-flash-image"), 1, 
                                1, NULL, args_buf->op);
-                if (rc == RTAS_RC_BUSY)
-                        udelay(1);
-                else if (rtas_is_extended_busy(rc)) {
-                        wait_time = rtas_extended_busy_delay_time(rc);
-                        udelay(wait_time * 1000);
-                } else
-                        break;
-        }
+        } while (rtas_busy_delay(rc));
 
         args_buf->status = rc;
 }
@@ -451,27 +443,18 @@ static ssize_t manage_flash_write(struct file *file, const char __user *buf,
 static void validate_flash(struct rtas_validate_flash_t *args_buf)
 {
         int token = rtas_token("ibm,validate-flash-image");
-        unsigned int wait_time;
         int update_results;
         s32 rc; 
 
         rc = 0;
-        while(1) {
+        do {
                 spin_lock(&rtas_data_buf_lock);
                 memcpy(rtas_data_buf, args_buf->buf, VALIDATE_BUF_SIZE);
                 rc = rtas_call(token, 2, 2, &update_results, 
                                (u32) __pa(rtas_data_buf), args_buf->buf_size);
                 memcpy(args_buf->buf, rtas_data_buf, VALIDATE_BUF_SIZE);
                 spin_unlock(&rtas_data_buf_lock);
-                        
-                if (rc == RTAS_RC_BUSY)
-                        udelay(1);
-                else if (rtas_is_extended_busy(rc)) {
-                        wait_time = rtas_extended_busy_delay_time(rc);
-                        udelay(wait_time * 1000);
-                } else
-                        break;
-        }
+        } while (rtas_busy_delay(rc));
 
         args_buf->status = rc;
         args_buf->update_results = update_results;
diff --git a/arch/powerpc/kernel/rtas_pci.c b/arch/powerpc/kernel/rtas_pci.c
index 57b539a03fa9..6eb7e49b394a 100644
--- a/arch/powerpc/kernel/rtas_pci.c
+++ b/arch/powerpc/kernel/rtas_pci.c
@@ -313,7 +313,9 @@ unsigned long __init find_and_init_phbs(void)
         for (node = of_get_next_child(root, NULL);
              node != NULL;
              node = of_get_next_child(root, node)) {
-                if (node->type == NULL || strcmp(node->type, "pci") != 0)
+
+                if (node->type == NULL || (strcmp(node->type, "pci") != 0 &&
+                                           strcmp(node->type, "pciex") != 0))
                         continue;
 
                 phb = pcibios_alloc_controller(node);
diff --git a/arch/powerpc/kernel/setup-common.c b/arch/powerpc/kernel/setup-common.c
index 684ab1d49c65..bd328123af75 100644
--- a/arch/powerpc/kernel/setup-common.c
+++ b/arch/powerpc/kernel/setup-common.c
@@ -443,6 +443,7 @@ void __init smp_setup_cpu_maps(void)
 }
 #endif /* CONFIG_SMP */
 
+int __initdata do_early_xmon;
 #ifdef CONFIG_XMON
 static int __init early_xmon(char *p)
 {
@@ -456,7 +457,7 @@ static int __init early_xmon(char *p)
                         return 0;
         }
         xmon_init(1);
-        debugger(NULL);
+        do_early_xmon = 1;
 
         return 0;
 }
@@ -524,3 +525,20 @@ int check_legacy_ioport(unsigned long base_port)
         return ppc_md.check_legacy_ioport(base_port);
 }
 EXPORT_SYMBOL(check_legacy_ioport);
+
+static int ppc_panic_event(struct notifier_block *this,
+                             unsigned long event, void *ptr)
+{
+        ppc_md.panic(ptr);  /* May not return */
+        return NOTIFY_DONE;
+}
+
+static struct notifier_block ppc_panic_block = {
+        .notifier_call = ppc_panic_event,
+        .priority = INT_MIN /* may not return; must be done last */
+};
+
+void __init setup_panic(void)
+{
+        atomic_notifier_chain_register(&panic_notifier_list, &ppc_panic_block);
+}
diff --git a/arch/powerpc/kernel/setup.h b/arch/powerpc/kernel/setup.h
index 2ebba755272e..4c67ad7fae08 100644
--- a/arch/powerpc/kernel/setup.h
+++ b/arch/powerpc/kernel/setup.h
@@ -2,5 +2,8 @@
 #define _POWERPC_KERNEL_SETUP_H
 
 void check_for_initrd(void);
+void do_init_bootmem(void);
+void setup_panic(void);
+extern int do_early_xmon;
 
 #endif /* _POWERPC_KERNEL_SETUP_H */
diff --git a/arch/powerpc/kernel/setup_32.c b/arch/powerpc/kernel/setup_32.c
index 69ac25701344..e5a44812441a 100644
--- a/arch/powerpc/kernel/setup_32.c
+++ b/arch/powerpc/kernel/setup_32.c
@@ -131,12 +131,6 @@ void __init machine_init(unsigned long dt_ptr, unsigned long phys)
         /* Do some early initialization based on the flat device tree */
         early_init_devtree(__va(dt_ptr));
 
-        /* Check default command line */
-#ifdef CONFIG_CMDLINE
-        if (cmd_line[0] == 0)
-                strlcpy(cmd_line, CONFIG_CMDLINE, sizeof(cmd_line));
-#endif /* CONFIG_CMDLINE */
-
         probe_machine();
 
 #ifdef CONFIG_6xx
@@ -235,7 +229,7 @@ arch_initcall(ppc_init);
 /* Warning, IO base is not yet inited */
 void __init setup_arch(char **cmdline_p)
 {
-        extern void do_init_bootmem(void);
+        *cmdline_p = cmd_line;
 
         /* so udelay does something sensible, assume <= 1000 bogomips */
         loops_per_jiffy = 500000000 / HZ;
@@ -285,16 +279,16 @@ void __init setup_arch(char **cmdline_p)
         /* reboot on panic */
         panic_timeout = 180;
 
+        if (ppc_md.panic)
+                setup_panic();
+
         init_mm.start_code = PAGE_OFFSET;
         init_mm.end_code = (unsigned long) _etext;
         init_mm.end_data = (unsigned long) _edata;
         init_mm.brk = klimit;
 
-        /* Save unparsed command line copy for /proc/cmdline */
-        strlcpy(saved_command_line, cmd_line, COMMAND_LINE_SIZE);
-        *cmdline_p = cmd_line;
-
-        parse_early_param();
+        if (do_early_xmon)
+                debugger(NULL);
 
         /* set up the bootmem stuff with available memory */
         do_init_bootmem();
diff --git a/arch/powerpc/kernel/setup_64.c b/arch/powerpc/kernel/setup_64.c
index 4467c49903b6..78f3a5fd43f6 100644
--- a/arch/powerpc/kernel/setup_64.c
+++ b/arch/powerpc/kernel/setup_64.c
@@ -100,12 +100,6 @@ unsigned long SYSRQ_KEY;
 #endif /* CONFIG_MAGIC_SYSRQ */
 
 
-static int ppc64_panic_event(struct notifier_block *, unsigned long, void *);
-static struct notifier_block ppc64_panic_block = {
-        .notifier_call = ppc64_panic_event,
-        .priority = INT_MIN /* may not return; must be done last */
-};
-
 #ifdef CONFIG_SMP
 
 static int smt_enabled_cmdline;
@@ -199,9 +193,7 @@ void __init early_setup(unsigned long dt_ptr)
         /* Probe the machine type */
         probe_machine();
 
-#ifdef CONFIG_CRASH_DUMP
-        kdump_setup();
-#endif
+        setup_kdump_trampoline();
 
         DBG("Found, Initializing memory management...\n");
 
@@ -353,9 +345,6 @@ void __init setup_system(void)
 {
         DBG(" -> setup_system()\n");
 
-#ifdef CONFIG_KEXEC
-        kdump_move_device_tree();
-#endif
         /*
          * Unflatten the device-tree passed by prom_init or kexec
          */
@@ -420,10 +409,8 @@ void __init setup_system(void)
          */
         register_early_udbg_console();
 
-        /* Save unparsed command line copy for /proc/cmdline */
-        strlcpy(saved_command_line, cmd_line, COMMAND_LINE_SIZE);
-
-        parse_early_param();
+        if (do_early_xmon)
+                debugger(NULL);
 
         check_smt_enabled();
         smp_setup_cpu_maps();
@@ -456,13 +443,6 @@ void __init setup_system(void)
         DBG(" <- setup_system()\n");
 }
 
-static int ppc64_panic_event(struct notifier_block *this,
-                             unsigned long event, void *ptr)
-{
-        ppc_md.panic((char *)ptr);  /* May not return */
-        return NOTIFY_DONE;
-}
-
 #ifdef CONFIG_IRQSTACKS
 static void __init irqstack_early_init(void)
 {
@@ -517,8 +497,6 @@ static void __init emergency_stack_init(void)
  */
 void __init setup_arch(char **cmdline_p)
 {
-        extern void do_init_bootmem(void);
-
         ppc64_boot_msg(0x12, "Setup Arch");
 
         *cmdline_p = cmd_line;
@@ -535,8 +513,7 @@ void __init setup_arch(char **cmdline_p)
         panic_timeout = 180;
 
         if (ppc_md.panic)
-                atomic_notifier_chain_register(&panic_notifier_list,
-                                &ppc64_panic_block);
+                setup_panic();
 
         init_mm.start_code = PAGE_OFFSET;
         init_mm.end_code = (unsigned long) _etext;
diff --git a/arch/powerpc/kernel/signal_32.c b/arch/powerpc/kernel/signal_32.c
index 8fdeca2d4597..d73b25e22fca 100644
--- a/arch/powerpc/kernel/signal_32.c
+++ b/arch/powerpc/kernel/signal_32.c
@@ -419,9 +419,7 @@ static long restore_user_regs(struct pt_regs *regs,
 {
         long err;
         unsigned int save_r2 = 0;
-#if defined(CONFIG_ALTIVEC) || defined(CONFIG_SPE)
         unsigned long msr;
-#endif
 
         /*
          * restore general registers but not including MSR or SOFTE. Also
@@ -430,11 +428,16 @@ static long restore_user_regs(struct pt_regs *regs,
         if (!sig)
                 save_r2 = (unsigned int)regs->gpr[2];
         err = restore_general_regs(regs, sr);
+        err |= __get_user(msr, &sr->mc_gregs[PT_MSR]);
         if (!sig)
                 regs->gpr[2] = (unsigned long) save_r2;
         if (err)
                 return 1;
 
+        /* if doing signal return, restore the previous little-endian mode */
+        if (sig)
+                regs->msr = (regs->msr & ~MSR_LE) | (msr & MSR_LE);
+
         /*
          * Do this before updating the thread state in
          * current->thread.fpr/vr/evr.  That way, if we get preempted
@@ -455,7 +458,7 @@ static long restore_user_regs(struct pt_regs *regs,
         /* force the process to reload the altivec registers from
            current->thread when it next does altivec instructions */
         regs->msr &= ~MSR_VEC;
-        if (!__get_user(msr, &sr->mc_gregs[PT_MSR]) && (msr & MSR_VEC) != 0) {
+        if (msr & MSR_VEC) {
                 /* restore altivec registers from the stack */
                 if (__copy_from_user(current->thread.vr, &sr->mc_vregs,
                                      sizeof(sr->mc_vregs)))
@@ -472,7 +475,7 @@ static long restore_user_regs(struct pt_regs *regs,
         /* force the process to reload the spe registers from
            current->thread when it next does spe instructions */
         regs->msr &= ~MSR_SPE;
-        if (!__get_user(msr, &sr->mc_gregs[PT_MSR]) && (msr & MSR_SPE) != 0) {
+        if (msr & MSR_SPE) {
                 /* restore spe registers from the stack */
                 if (__copy_from_user(current->thread.evr, &sr->mc_vregs,
                                      ELF_NEVRREG * sizeof(u32)))
@@ -757,10 +760,10 @@ static int handle_rt_signal(unsigned long sig, struct k_sigaction *ka,
 
         /* Save user registers on the stack */
         frame = &rt_sf->uc.uc_mcontext;
-        if (vdso32_rt_sigtramp && current->thread.vdso_base) {
+        if (vdso32_rt_sigtramp && current->mm->context.vdso_base) {
                 if (save_user_regs(regs, frame, 0))
                         goto badframe;
-                regs->link = current->thread.vdso_base + vdso32_rt_sigtramp;
+                regs->link = current->mm->context.vdso_base + vdso32_rt_sigtramp;
         } else {
                 if (save_user_regs(regs, frame, __NR_rt_sigreturn))
                         goto badframe;
@@ -777,6 +780,8 @@ static int handle_rt_signal(unsigned long sig, struct k_sigaction *ka,
         regs->gpr[5] = (unsigned long) &rt_sf->uc;
         regs->gpr[6] = (unsigned long) rt_sf;
         regs->nip = (unsigned long) ka->sa.sa_handler;
+        /* enter the signal handler in big-endian mode */
+        regs->msr &= ~MSR_LE;
         regs->trap = 0;
         return 1;
 
@@ -1038,10 +1043,10 @@ static int handle_signal(unsigned long sig, struct k_sigaction *ka,
             || __put_user(sig, &sc->signal))
                 goto badframe;
 
-        if (vdso32_sigtramp && current->thread.vdso_base) {
+        if (vdso32_sigtramp && current->mm->context.vdso_base) {
                 if (save_user_regs(regs, &frame->mctx, 0))
                         goto badframe;
-                regs->link = current->thread.vdso_base + vdso32_sigtramp;
+                regs->link = current->mm->context.vdso_base + vdso32_sigtramp;
         } else {
                 if (save_user_regs(regs, &frame->mctx, __NR_sigreturn))
                         goto badframe;
@@ -1056,6 +1061,8 @@ static int handle_signal(unsigned long sig, struct k_sigaction *ka,
         regs->gpr[3] = sig;
         regs->gpr[4] = (unsigned long) sc;
         regs->nip = (unsigned long) ka->sa.sa_handler;
+        /* enter the signal handler in big-endian mode */
+        regs->msr &= ~MSR_LE;
         regs->trap = 0;
 
         return 1;
diff --git a/arch/powerpc/kernel/signal_64.c b/arch/powerpc/kernel/signal_64.c
index c2db642f4cdd..6e75d7ab6d4d 100644
--- a/arch/powerpc/kernel/signal_64.c
+++ b/arch/powerpc/kernel/signal_64.c
@@ -141,9 +141,7 @@ static long restore_sigcontext(struct pt_regs *regs, sigset_t *set, int sig,
         unsigned long err = 0;
         unsigned long save_r13 = 0;
         elf_greg_t *gregs = (elf_greg_t *)regs;
-#ifdef CONFIG_ALTIVEC
         unsigned long msr;
-#endif
         int i;
 
         /* If this is not a signal return, we preserve the TLS in r13 */
@@ -154,7 +152,12 @@ static long restore_sigcontext(struct pt_regs *regs, sigset_t *set, int sig,
         err |= __copy_from_user(regs, &sc->gp_regs,
                                 PT_MSR*sizeof(unsigned long));
 
-        /* skip MSR and SOFTE */
+        /* get MSR separately, transfer the LE bit if doing signal return */
+        err |= __get_user(msr, &sc->gp_regs[PT_MSR]);
+        if (sig)
+                regs->msr = (regs->msr & ~MSR_LE) | (msr & MSR_LE);
+
+        /* skip SOFTE */
         for (i = PT_MSR+1; i <= PT_RESULT; i++) {
                 if (i == PT_SOFTE)
                         continue;
@@ -179,7 +182,6 @@ static long restore_sigcontext(struct pt_regs *regs, sigset_t *set, int sig,
 
 #ifdef CONFIG_ALTIVEC
         err |= __get_user(v_regs, &sc->v_regs);
-        err |= __get_user(msr, &sc->gp_regs[PT_MSR]);
         if (err)
                 return err;
         if (v_regs && !access_ok(VERIFY_READ, v_regs, 34 * sizeof(vector128)))
@@ -396,8 +398,8 @@ static int setup_rt_frame(int signr, struct k_sigaction *ka, siginfo_t *info,
         current->thread.fpscr.val = 0;
 
         /* Set up to return from userspace. */
-        if (vdso64_rt_sigtramp && current->thread.vdso_base) {
-                regs->link = current->thread.vdso_base + vdso64_rt_sigtramp;
+        if (vdso64_rt_sigtramp && current->mm->context.vdso_base) {
+                regs->link = current->mm->context.vdso_base + vdso64_rt_sigtramp;
         } else {
                 err |= setup_trampoline(__NR_rt_sigreturn, &frame->tramp[0]);
                 if (err)
@@ -412,6 +414,8 @@ static int setup_rt_frame(int signr, struct k_sigaction *ka, siginfo_t *info,
 
         /* Set up "regs" so we "return" to the signal handler. */
         err |= get_user(regs->nip, &funct_desc_ptr->entry);
+        /* enter the signal handler in big-endian mode */
+        regs->msr &= ~MSR_LE;
         regs->gpr[1] = newsp;
         err |= get_user(regs->gpr[2], &funct_desc_ptr->toc);
         regs->gpr[3] = signr;
diff --git a/arch/powerpc/kernel/smp.c b/arch/powerpc/kernel/smp.c
index 530f7dba0bd2..c5d179d4f818 100644
--- a/arch/powerpc/kernel/smp.c
+++ b/arch/powerpc/kernel/smp.c
@@ -492,7 +492,7 @@ int __devinit __cpu_up(unsigned int cpu)
          * -- Cort
          */
         if (system_state < SYSTEM_RUNNING)
-                for (c = 5000; c && !cpu_callin_map[cpu]; c--)
+                for (c = 50000; c && !cpu_callin_map[cpu]; c--)
                         udelay(100);
 #ifdef CONFIG_HOTPLUG_CPU
         else
diff --git a/arch/powerpc/kernel/systbl.S b/arch/powerpc/kernel/systbl.S
index 26ed1f5ef16e..ee75ccf1a802 100644
--- a/arch/powerpc/kernel/systbl.S
+++ b/arch/powerpc/kernel/systbl.S
@@ -32,6 +32,10 @@
 #define SYS32ONLY(func)         .long   sys_##func
 #define SYSX(f, f3264, f32)     .long   f32
 #endif
+#define SYSCALL_SPU(func)       SYSCALL(func)
+#define COMPAT_SYS_SPU(func)    COMPAT_SYS(func)
+#define PPC_SYS_SPU(func)       PPC_SYS(func)
+#define SYSX_SPU(f, f3264, f32) SYSX(f, f3264, f32)
 
 #ifdef CONFIG_PPC64
 #define sys_sigpending  sys_ni_syscall
@@ -39,309 +43,4 @@
 #endif
 
 _GLOBAL(sys_call_table)
-SYSCALL(restart_syscall)
-SYSCALL(exit)
-PPC_SYS(fork)
-SYSCALL(read)
-SYSCALL(write)
-COMPAT_SYS(open)
-SYSCALL(close)
-COMPAT_SYS(waitpid)
-COMPAT_SYS(creat)
-SYSCALL(link)
-SYSCALL(unlink)
-COMPAT_SYS(execve)
-SYSCALL(chdir)
-COMPAT_SYS(time)
-SYSCALL(mknod)
-SYSCALL(chmod)
-SYSCALL(lchown)
-SYSCALL(ni_syscall)
-OLDSYS(stat)
-SYSX(sys_lseek,ppc32_lseek,sys_lseek)
-SYSCALL(getpid)
-COMPAT_SYS(mount)
-SYSX(sys_ni_syscall,sys_oldumount,sys_oldumount)
-SYSCALL(setuid)
-SYSCALL(getuid)
-COMPAT_SYS(stime)
-COMPAT_SYS(ptrace)
-SYSCALL(alarm)
-OLDSYS(fstat)
-COMPAT_SYS(pause)
-COMPAT_SYS(utime)
-SYSCALL(ni_syscall)
-SYSCALL(ni_syscall)
-COMPAT_SYS(access)
-COMPAT_SYS(nice)
-SYSCALL(ni_syscall)
-SYSCALL(sync)
-COMPAT_SYS(kill)
-SYSCALL(rename)
-COMPAT_SYS(mkdir)
-SYSCALL(rmdir)
-SYSCALL(dup)
-SYSCALL(pipe)
-COMPAT_SYS(times)
-SYSCALL(ni_syscall)
-SYSCALL(brk)
-SYSCALL(setgid)
-SYSCALL(getgid)
-SYSCALL(signal)
-SYSCALL(geteuid)
-SYSCALL(getegid)
-SYSCALL(acct)
-SYSCALL(umount)
-SYSCALL(ni_syscall)
-COMPAT_SYS(ioctl)
-COMPAT_SYS(fcntl)
-SYSCALL(ni_syscall)
-COMPAT_SYS(setpgid)
-SYSCALL(ni_syscall)
-SYSX(sys_ni_syscall,sys_olduname, sys_olduname)
-COMPAT_SYS(umask)
-SYSCALL(chroot)
-SYSCALL(ustat)
-SYSCALL(dup2)
-SYSCALL(getppid)
-SYSCALL(getpgrp)
-SYSCALL(setsid)
-SYS32ONLY(sigaction)
-SYSCALL(sgetmask)
-COMPAT_SYS(ssetmask)
-SYSCALL(setreuid)
-SYSCALL(setregid)
-SYS32ONLY(sigsuspend)
-COMPAT_SYS(sigpending)
-COMPAT_SYS(sethostname)
-COMPAT_SYS(setrlimit)
-COMPAT_SYS(old_getrlimit)
-COMPAT_SYS(getrusage)
-COMPAT_SYS(gettimeofday)
-COMPAT_SYS(settimeofday)
-COMPAT_SYS(getgroups)
-COMPAT_SYS(setgroups)
-SYSX(sys_ni_syscall,sys_ni_syscall,ppc_select)
-SYSCALL(symlink)
-OLDSYS(lstat)
-COMPAT_SYS(readlink)
-SYSCALL(uselib)
-SYSCALL(swapon)
-SYSCALL(reboot)
-SYSX(sys_ni_syscall,old32_readdir,old_readdir)
-SYSCALL(mmap)
-SYSCALL(munmap)
-SYSCALL(truncate)
-SYSCALL(ftruncate)
-SYSCALL(fchmod)
-SYSCALL(fchown)
-COMPAT_SYS(getpriority)
-COMPAT_SYS(setpriority)
-SYSCALL(ni_syscall)
-COMPAT_SYS(statfs)
-COMPAT_SYS(fstatfs)
-SYSCALL(ni_syscall)
-COMPAT_SYS(socketcall)
-COMPAT_SYS(syslog)
-COMPAT_SYS(setitimer)
-COMPAT_SYS(getitimer)
-COMPAT_SYS(newstat)
-COMPAT_SYS(newlstat)
-COMPAT_SYS(newfstat)
-SYSX(sys_ni_syscall,sys_uname,sys_uname)
-SYSCALL(ni_syscall)
-SYSCALL(vhangup)
-SYSCALL(ni_syscall)
-SYSCALL(ni_syscall)
-COMPAT_SYS(wait4)
-SYSCALL(swapoff)
-COMPAT_SYS(sysinfo)
-COMPAT_SYS(ipc)
-SYSCALL(fsync)
-SYS32ONLY(sigreturn)
-PPC_SYS(clone)
-COMPAT_SYS(setdomainname)
-PPC_SYS(newuname)
-SYSCALL(ni_syscall)
-COMPAT_SYS(adjtimex)
-SYSCALL(mprotect)
-SYSX(sys_ni_syscall,compat_sys_sigprocmask,sys_sigprocmask)
-SYSCALL(ni_syscall)
-SYSCALL(init_module)
-SYSCALL(delete_module)
-SYSCALL(ni_syscall)
-SYSCALL(quotactl)
-COMPAT_SYS(getpgid)
-SYSCALL(fchdir)
-SYSCALL(bdflush)
-COMPAT_SYS(sysfs)
-SYSX(ppc64_personality,ppc64_personality,sys_personality)
-SYSCALL(ni_syscall)
-SYSCALL(setfsuid)
-SYSCALL(setfsgid)
-SYSCALL(llseek)
-COMPAT_SYS(getdents)
-SYSX(sys_select,ppc32_select,ppc_select)
-SYSCALL(flock)
-SYSCALL(msync)
-COMPAT_SYS(readv)
-COMPAT_SYS(writev)
-COMPAT_SYS(getsid)
-SYSCALL(fdatasync)
-COMPAT_SYS(sysctl)
-SYSCALL(mlock)
-SYSCALL(munlock)
-SYSCALL(mlockall)
-SYSCALL(munlockall)
-COMPAT_SYS(sched_setparam)
-COMPAT_SYS(sched_getparam)
-COMPAT_SYS(sched_setscheduler)
-COMPAT_SYS(sched_getscheduler)
-SYSCALL(sched_yield)
-COMPAT_SYS(sched_get_priority_max)
-COMPAT_SYS(sched_get_priority_min)
-COMPAT_SYS(sched_rr_get_interval)
-COMPAT_SYS(nanosleep)
-SYSCALL(mremap)
-SYSCALL(setresuid)
-SYSCALL(getresuid)
-SYSCALL(ni_syscall)
-SYSCALL(poll)
-COMPAT_SYS(nfsservctl)
-SYSCALL(setresgid)
-SYSCALL(getresgid)
-COMPAT_SYS(prctl)
-COMPAT_SYS(rt_sigreturn)
-COMPAT_SYS(rt_sigaction)
-COMPAT_SYS(rt_sigprocmask)
-COMPAT_SYS(rt_sigpending)
-COMPAT_SYS(rt_sigtimedwait)
-COMPAT_SYS(rt_sigqueueinfo)
-COMPAT_SYS(rt_sigsuspend)
-COMPAT_SYS(pread64)
-COMPAT_SYS(pwrite64)
-SYSCALL(chown)
-SYSCALL(getcwd)
-SYSCALL(capget)
-SYSCALL(capset)
-COMPAT_SYS(sigaltstack)
-SYSX(sys_sendfile64,compat_sys_sendfile,sys_sendfile)
-SYSCALL(ni_syscall)
-SYSCALL(ni_syscall)
-PPC_SYS(vfork)
-COMPAT_SYS(getrlimit)
-COMPAT_SYS(readahead)
-SYS32ONLY(mmap2)
-SYS32ONLY(truncate64)
-SYS32ONLY(ftruncate64)
-SYSX(sys_ni_syscall,sys_stat64,sys_stat64)
-SYSX(sys_ni_syscall,sys_lstat64,sys_lstat64)
-SYSX(sys_ni_syscall,sys_fstat64,sys_fstat64)
-SYSCALL(pciconfig_read)
-SYSCALL(pciconfig_write)
-SYSCALL(pciconfig_iobase)
-SYSCALL(ni_syscall)
-SYSCALL(getdents64)
-SYSCALL(pivot_root)
-SYSX(sys_ni_syscall,compat_sys_fcntl64,sys_fcntl64)
-SYSCALL(madvise)
-SYSCALL(mincore)
-SYSCALL(gettid)
-SYSCALL(tkill)
-SYSCALL(setxattr)
-SYSCALL(lsetxattr)
-SYSCALL(fsetxattr)
-SYSCALL(getxattr)
-SYSCALL(lgetxattr)
-SYSCALL(fgetxattr)
-SYSCALL(listxattr)
-SYSCALL(llistxattr)
-SYSCALL(flistxattr)
-SYSCALL(removexattr)
-SYSCALL(lremovexattr)
-SYSCALL(fremovexattr)
-COMPAT_SYS(futex)
-COMPAT_SYS(sched_setaffinity)
-COMPAT_SYS(sched_getaffinity)
-SYSCALL(ni_syscall)
-SYSCALL(ni_syscall)
-SYS32ONLY(sendfile64)
-COMPAT_SYS(io_setup)
-SYSCALL(io_destroy)
-COMPAT_SYS(io_getevents)
-COMPAT_SYS(io_submit)
-SYSCALL(io_cancel)
-SYSCALL(set_tid_address)
-SYSX(sys_fadvise64,ppc32_fadvise64,sys_fadvise64)
-SYSCALL(exit_group)
-SYSX(sys_lookup_dcookie,ppc32_lookup_dcookie,sys_lookup_dcookie)
-SYSCALL(epoll_create)
-SYSCALL(epoll_ctl)
-SYSCALL(epoll_wait)
-SYSCALL(remap_file_pages)
-SYSX(sys_timer_create,compat_sys_timer_create,sys_timer_create)
-COMPAT_SYS(timer_settime)
-COMPAT_SYS(timer_gettime)
-SYSCALL(timer_getoverrun)
-SYSCALL(timer_delete)
-COMPAT_SYS(clock_settime)
-COMPAT_SYS(clock_gettime)
-COMPAT_SYS(clock_getres)
-COMPAT_SYS(clock_nanosleep)
-SYSX(ppc64_swapcontext,ppc32_swapcontext,ppc_swapcontext)
-COMPAT_SYS(tgkill)
-COMPAT_SYS(utimes)
-COMPAT_SYS(statfs64)
-COMPAT_SYS(fstatfs64)
-SYSX(sys_ni_syscall, ppc_fadvise64_64, ppc_fadvise64_64)
-PPC_SYS(rtas)
-OLDSYS(debug_setcontext)
-SYSCALL(ni_syscall)
-SYSCALL(ni_syscall)
-COMPAT_SYS(mbind)
-COMPAT_SYS(get_mempolicy)
-COMPAT_SYS(set_mempolicy)
-COMPAT_SYS(mq_open)
-SYSCALL(mq_unlink)
-COMPAT_SYS(mq_timedsend)
-COMPAT_SYS(mq_timedreceive)
-COMPAT_SYS(mq_notify)
-COMPAT_SYS(mq_getsetattr)
-COMPAT_SYS(kexec_load)
-COMPAT_SYS(add_key)
-COMPAT_SYS(request_key)
-COMPAT_SYS(keyctl)
-COMPAT_SYS(waitid)
-COMPAT_SYS(ioprio_set)
-COMPAT_SYS(ioprio_get)
-SYSCALL(inotify_init)
-SYSCALL(inotify_add_watch)
-SYSCALL(inotify_rm_watch)
-SYSCALL(spu_run)
-SYSCALL(spu_create)
-COMPAT_SYS(pselect6)
-COMPAT_SYS(ppoll)
-SYSCALL(unshare)
-SYSCALL(splice)
-SYSCALL(tee)
-SYSCALL(vmsplice)
-COMPAT_SYS(openat)
-SYSCALL(mkdirat)
-SYSCALL(mknodat)
-SYSCALL(fchownat)
-COMPAT_SYS(futimesat)
-SYSX(sys_newfstatat, sys_fstatat64, sys_fstatat64)
-SYSCALL(unlinkat)
-SYSCALL(renameat)
-SYSCALL(linkat)
-SYSCALL(symlinkat)
-SYSCALL(readlinkat)
-SYSCALL(fchmodat)
-SYSCALL(faccessat)
-COMPAT_SYS(get_robust_list)
-COMPAT_SYS(set_robust_list)
-
-/*
- * please add new calls to arch/powerpc/platforms/cell/spu_callbacks.c
- * as well when appropriate.
- */
+#include <asm/systbl.h>
diff --git a/arch/powerpc/kernel/time.c b/arch/powerpc/kernel/time.c
index 24e3ad756de0..d20907561f46 100644
--- a/arch/powerpc/kernel/time.c
+++ b/arch/powerpc/kernel/time.c
@@ -76,7 +76,6 @@
 
 /* keep track of when we need to update the rtc */
 time_t last_rtc_update;
-extern int piranha_simulator;
 #ifdef CONFIG_PPC_ISERIES
 unsigned long iSeries_recal_titan = 0;
 unsigned long iSeries_recal_tb = 0; 
@@ -858,42 +857,50 @@ int do_settimeofday(struct timespec *tv)
 
 EXPORT_SYMBOL(do_settimeofday);
 
-void __init generic_calibrate_decr(void)
+static int __init get_freq(char *name, int cells, unsigned long *val)
 {
         struct device_node *cpu;
         unsigned int *fp;
-        int node_found;
+        int found = 0;
 
-        /*
-         * The cpu node should have a timebase-frequency property
-         * to tell us the rate at which the decrementer counts.
-         */
+        /* The cpu node should have timebase and clock frequency properties */
         cpu = of_find_node_by_type(NULL, "cpu");
 
-        ppc_tb_freq = DEFAULT_TB_FREQ;          /* hardcoded default */
-        node_found = 0;
         if (cpu) {
-                fp = (unsigned int *)get_property(cpu, "timebase-frequency",
-                                                  NULL);
+                fp = (unsigned int *)get_property(cpu, name, NULL);
                 if (fp) {
-                        node_found = 1;
-                        ppc_tb_freq = *fp;
+                        found = 1;
+                        *val = 0;
+                        while (cells--)
+                                *val = (*val << 32) | *fp++;
                 }
+
+                of_node_put(cpu);
         }
-        if (!node_found)
+
+        return found;
+}
+
+void __init generic_calibrate_decr(void)
+{
+        ppc_tb_freq = DEFAULT_TB_FREQ;          /* hardcoded default */
+
+        if (!get_freq("ibm,extended-timebase-frequency", 2, &ppc_tb_freq) &&
+            !get_freq("timebase-frequency", 1, &ppc_tb_freq)) {
+
                 printk(KERN_ERR "WARNING: Estimating decrementer frequency "
                                 "(not found)\n");
+        }
 
-        ppc_proc_freq = DEFAULT_PROC_FREQ;
-        node_found = 0;
-        if (cpu) {
-                fp = (unsigned int *)get_property(cpu, "clock-frequency",
-                                                  NULL);
-                if (fp) {
-                        node_found = 1;
-                        ppc_proc_freq = *fp;
-                }
+        ppc_proc_freq = DEFAULT_PROC_FREQ;      /* hardcoded default */
+
+        if (!get_freq("ibm,extended-clock-frequency", 2, &ppc_proc_freq) &&
+            !get_freq("clock-frequency", 1, &ppc_proc_freq)) {
+
+                printk(KERN_ERR "WARNING: Estimating processor frequency "
+                                "(not found)\n");
         }
+
 #ifdef CONFIG_BOOKE
         /* Set the time base to zero */
         mtspr(SPRN_TBWL, 0);
@@ -905,11 +912,6 @@ void __init generic_calibrate_decr(void)
         /* Enable decrementer interrupt */
         mtspr(SPRN_TCR, TCR_DIE);
 #endif
-        if (!node_found)
-                printk(KERN_ERR "WARNING: Estimating processor frequency "
-                                "(not found)\n");
-
-        of_node_put(cpu);
 }
 
 unsigned long get_boot_time(void)
@@ -945,9 +947,9 @@ void __init time_init(void)
         } else {
                 /* Normal PowerPC with timebase register */
                 ppc_md.calibrate_decr();
-                printk(KERN_INFO "time_init: decrementer frequency = %lu.%.6lu MHz\n",
+                printk(KERN_DEBUG "time_init: decrementer frequency = %lu.%.6lu MHz\n",
                        ppc_tb_freq / 1000000, ppc_tb_freq % 1000000);
-                printk(KERN_INFO "time_init: processor frequency   = %lu.%.6lu MHz\n",
+                printk(KERN_DEBUG "time_init: processor frequency   = %lu.%.6lu MHz\n",
                        ppc_proc_freq / 1000000, ppc_proc_freq % 1000000);
                 tb_last_stamp = tb_last_jiffy = get_tb();
         }
@@ -1010,10 +1012,7 @@ void __init time_init(void)
         tb_to_ns_scale = scale;
         tb_to_ns_shift = shift;
 
-#ifdef CONFIG_PPC_ISERIES
-        if (!piranha_simulator)
-#endif
-                tm = get_boot_time();
+        tm = get_boot_time();
 
         write_seqlock_irqsave(&xtime_lock, flags);
 
diff --git a/arch/powerpc/kernel/traps.c b/arch/powerpc/kernel/traps.c
index 064a52564692..91a6e04d9741 100644
--- a/arch/powerpc/kernel/traps.c
+++ b/arch/powerpc/kernel/traps.c
@@ -658,7 +658,7 @@ static int emulate_instruction(struct pt_regs *regs)
         u32 instword;
         u32 rd;
 
-        if (!user_mode(regs))
+        if (!user_mode(regs) || (regs->msr & MSR_LE))
                 return -EINVAL;
         CHECK_FULL_REGS(regs);
 
@@ -805,9 +805,11 @@ void __kprobes program_check_exception(struct pt_regs *regs)
 
 void alignment_exception(struct pt_regs *regs)
 {
-        int fixed;
+        int fixed = 0;
 
-        fixed = fix_alignment(regs);
+        /* we don't implement logging of alignment exceptions */
+        if (!(current->thread.align_ctl & PR_UNALIGN_SIGBUS))
+                fixed = fix_alignment(regs);
 
         if (fixed == 1) {
                 regs->nip += 4; /* skip over emulated instruction */
diff --git a/arch/powerpc/kernel/udbg.c b/arch/powerpc/kernel/udbg.c
index 3774e80094f5..67d9fd9ae2b5 100644
--- a/arch/powerpc/kernel/udbg.c
+++ b/arch/powerpc/kernel/udbg.c
@@ -14,6 +14,7 @@
 #include <linux/types.h>
 #include <linux/sched.h>
 #include <linux/console.h>
+#include <linux/init.h>
 #include <asm/processor.h>
 #include <asm/udbg.h>
 
@@ -141,12 +142,14 @@ static int early_console_initialized;
 
 void __init disable_early_printk(void)
 {
-#if 1
         if (!early_console_initialized)
                 return;
+        if (strstr(saved_command_line, "udbg-immortal")) {
+                printk(KERN_INFO "early console immortal !\n");
+                return;
+        }
         unregister_console(&udbg_console);
         early_console_initialized = 0;
-#endif
 }
 
 /* called by setup_system */
diff --git a/arch/powerpc/kernel/vdso.c b/arch/powerpc/kernel/vdso.c
index 573afb68d69e..bc3e15be3087 100644
--- a/arch/powerpc/kernel/vdso.c
+++ b/arch/powerpc/kernel/vdso.c
@@ -223,6 +223,7 @@ int arch_setup_additional_pages(struct linux_binprm *bprm,
         struct vm_area_struct *vma;
         unsigned long vdso_pages;
         unsigned long vdso_base;
+        int rc;
 
 #ifdef CONFIG_PPC64
         if (test_thread_flag(TIF_32BIT)) {
@@ -237,20 +238,13 @@ int arch_setup_additional_pages(struct linux_binprm *bprm,
         vdso_base = VDSO32_MBASE;
 #endif
 
-        current->thread.vdso_base = 0;
+        current->mm->context.vdso_base = 0;
 
         /* vDSO has a problem and was disabled, just don't "enable" it for the
          * process
          */
         if (vdso_pages == 0)
                 return 0;
-
-        vma = kmem_cache_alloc(vm_area_cachep, SLAB_KERNEL);
-        if (vma == NULL)
-                return -ENOMEM;
-
-        memset(vma, 0, sizeof(*vma));
-
         /* Add a page to the vdso size for the data page */
         vdso_pages ++;
 
@@ -259,17 +253,23 @@ int arch_setup_additional_pages(struct linux_binprm *bprm,
          * at vdso_base which is the "natural" base for it, but we might fail
          * and end up putting it elsewhere.
          */
+        down_write(&mm->mmap_sem);
         vdso_base = get_unmapped_area(NULL, vdso_base,
                                       vdso_pages << PAGE_SHIFT, 0, 0);
-        if (vdso_base & ~PAGE_MASK) {
-                kmem_cache_free(vm_area_cachep, vma);
-                return (int)vdso_base;
+        if (IS_ERR_VALUE(vdso_base)) {
+                rc = vdso_base;
+                goto fail_mmapsem;
         }
 
-        current->thread.vdso_base = vdso_base;
 
+        /* Allocate a VMA structure and fill it up */
+        vma = kmem_cache_zalloc(vm_area_cachep, SLAB_KERNEL);
+        if (vma == NULL) {
+                rc = -ENOMEM;
+                goto fail_mmapsem;
+        }
         vma->vm_mm = mm;
-        vma->vm_start = current->thread.vdso_base;
+        vma->vm_start = vdso_base;
         vma->vm_end = vma->vm_start + (vdso_pages << PAGE_SHIFT);
 
         /*
@@ -282,23 +282,38 @@ int arch_setup_additional_pages(struct linux_binprm *bprm,
          * It's fine to use that for setting breakpoints in the vDSO code
          * pages though
          */
-        vma->vm_flags = VM_READ | VM_EXEC | VM_MAYREAD | VM_MAYWRITE | VM_MAYEXEC;
+        vma->vm_flags = VM_READ|VM_EXEC|VM_MAYREAD|VM_MAYWRITE|VM_MAYEXEC;
         vma->vm_flags |= mm->def_flags;
         vma->vm_page_prot = protection_map[vma->vm_flags & 0x7];
         vma->vm_ops = &vdso_vmops;
 
-        down_write(&mm->mmap_sem);
-        if (insert_vm_struct(mm, vma)) {
-                up_write(&mm->mmap_sem);
-                kmem_cache_free(vm_area_cachep, vma);
-                return -ENOMEM;
-        }
+        /* Insert new VMA */
+        rc = insert_vm_struct(mm, vma);
+        if (rc)
+                goto fail_vma;
+
+        /* Put vDSO base into mm struct and account for memory usage */
+        current->mm->context.vdso_base = vdso_base;
         mm->total_vm += (vma->vm_end - vma->vm_start) >> PAGE_SHIFT;
         up_write(&mm->mmap_sem);
-
         return 0;
+
+ fail_vma:
+        kmem_cache_free(vm_area_cachep, vma);
+ fail_mmapsem:
+        up_write(&mm->mmap_sem);
+        return rc;
+}
+
+const char *arch_vma_name(struct vm_area_struct *vma)
+{
+        if (vma->vm_mm && vma->vm_start == vma->vm_mm->context.vdso_base)
+                return "[vdso]";
+        return NULL;
 }
 
+
+
 static void * __init find_section32(Elf32_Ehdr *ehdr, const char *secname,
                                   unsigned long *size)
 {
diff --git a/arch/powerpc/kernel/vector.S b/arch/powerpc/kernel/vector.S
index 66b3d03c5fa5..9416b4ab92ec 100644
--- a/arch/powerpc/kernel/vector.S
+++ b/arch/powerpc/kernel/vector.S
@@ -53,12 +53,12 @@ fpenable:
         stfd    fr31,8(r1)
         LDCONST(fr1, fpzero)
         mffs    fr31
-        mtfsf   0xff,fr1
+        MTFSF_L(fr1)
         blr
 
 fpdisable:
         mtlr    r12
-        mtfsf   0xff,fr31
+        MTFSF_L(fr31)
         lfd     fr31,8(r1)
         lfd     fr1,16(r1)
         lfd     fr0,24(r1)
diff --git a/arch/powerpc/kernel/vio.c b/arch/powerpc/kernel/vio.c
index 971020cf3f7d..cdf5867838a6 100644
--- a/arch/powerpc/kernel/vio.c
+++ b/arch/powerpc/kernel/vio.c
@@ -13,27 +13,116 @@
  *      2 of the License, or (at your option) any later version.
  */
 
+#include <linux/types.h>
+#include <linux/device.h>
 #include <linux/init.h>
 #include <linux/console.h>
 #include <linux/module.h>
 #include <linux/mm.h>
 #include <linux/dma-mapping.h>
+#include <linux/kobject.h>
+
 #include <asm/iommu.h>
 #include <asm/dma.h>
 #include <asm/vio.h>
 #include <asm/prom.h>
-
-static const struct vio_device_id *vio_match_device(
-                const struct vio_device_id *, const struct vio_dev *);
-
-struct vio_dev vio_bus_device  = { /* fake "parent" device */
+#include <asm/firmware.h>
+#include <asm/tce.h>
+#include <asm/abs_addr.h>
+#include <asm/page.h>
+#include <asm/hvcall.h>
+#include <asm/iseries/vio.h>
+#include <asm/iseries/hv_types.h>
+#include <asm/iseries/hv_lp_config.h>
+#include <asm/iseries/hv_call_xm.h>
+#include <asm/iseries/iommu.h>
+
+extern struct subsystem devices_subsys; /* needed for vio_find_name() */
+
+static struct vio_dev vio_bus_device  = { /* fake "parent" device */
         .name = vio_bus_device.dev.bus_id,
         .type = "",
         .dev.bus_id = "vio",
         .dev.bus = &vio_bus_type,
 };
 
-static struct vio_bus_ops vio_bus_ops;
+#ifdef CONFIG_PPC_ISERIES
+struct device *iSeries_vio_dev = &vio_bus_device.dev;
+EXPORT_SYMBOL(iSeries_vio_dev);
+
+static struct iommu_table veth_iommu_table;
+static struct iommu_table vio_iommu_table;
+
+static void __init iommu_vio_init(void)
+{
+        iommu_table_getparms_iSeries(255, 0, 0xff, &veth_iommu_table);
+        veth_iommu_table.it_size /= 2;
+        vio_iommu_table = veth_iommu_table;
+        vio_iommu_table.it_offset += veth_iommu_table.it_size;
+
+        if (!iommu_init_table(&veth_iommu_table, -1))
+                printk("Virtual Bus VETH TCE table failed.\n");
+        if (!iommu_init_table(&vio_iommu_table, -1))
+                printk("Virtual Bus VIO TCE table failed.\n");
+}
+#endif
+
+static struct iommu_table *vio_build_iommu_table(struct vio_dev *dev)
+{
+#ifdef CONFIG_PPC_ISERIES
+        if (firmware_has_feature(FW_FEATURE_ISERIES)) {
+                if (strcmp(dev->type, "network") == 0)
+                        return &veth_iommu_table;
+                return &vio_iommu_table;
+        } else
+#endif
+        {
+                unsigned char *dma_window;
+                struct iommu_table *tbl;
+                unsigned long offset, size;
+
+                dma_window = get_property(dev->dev.platform_data,
+                                "ibm,my-dma-window", NULL);
+                if (!dma_window)
+                        return NULL;
+
+                tbl = kmalloc(sizeof(*tbl), GFP_KERNEL);
+
+                of_parse_dma_window(dev->dev.platform_data, dma_window,
+                                &tbl->it_index, &offset, &size);
+
+                /* TCE table size - measured in tce entries */
+                tbl->it_size = size >> PAGE_SHIFT;
+                /* offset for VIO should always be 0 */
+                tbl->it_offset = offset >> PAGE_SHIFT;
+                tbl->it_busno = 0;
+                tbl->it_type = TCE_VB;
+
+                return iommu_init_table(tbl, -1);
+        }
+}
+
+/**
+ * vio_match_device: - Tell if a VIO device has a matching
+ *                      VIO device id structure.
+ * @ids:        array of VIO device id structures to search in
+ * @dev:        the VIO device structure to match against
+ *
+ * Used by a driver to check whether a VIO device present in the
+ * system is in its list of supported devices. Returns the matching
+ * vio_device_id structure or NULL if there is no match.
+ */
+static const struct vio_device_id *vio_match_device(
+                const struct vio_device_id *ids, const struct vio_dev *dev)
+{
+        while (ids->type[0] != '\0') {
+                if ((strncmp(dev->type, ids->type, strlen(ids->type)) == 0) &&
+                    device_is_compatible(dev->dev.platform_data, ids->compat))
+                        return ids;
+                ids++;
+        }
+        return NULL;
+}
 
 /*
  * Convert from struct device to struct vio_dev and pass to driver.
@@ -106,35 +195,110 @@ void vio_unregister_driver(struct vio_driver *viodrv)
 }
 EXPORT_SYMBOL(vio_unregister_driver);
 
+/* vio_dev refcount hit 0 */
+static void __devinit vio_dev_release(struct device *dev)
+{
+        if (dev->platform_data) {
+                /* XXX free TCE table */
+                of_node_put(dev->platform_data);
+        }
+        kfree(to_vio_dev(dev));
+}
+
 /**
- * vio_match_device: - Tell if a VIO device has a matching
- *                      VIO device id structure.
- * @ids:        array of VIO device id structures to search in
- * @dev:        the VIO device structure to match against
+ * vio_register_device_node: - Register a new vio device.
+ * @of_node:    The OF node for this device.
  *
- * Used by a driver to check whether a VIO device present in the
- * system is in its list of supported devices. Returns the matching
- * vio_device_id structure or NULL if there is no match.
+ * Creates and initializes a vio_dev structure from the data in
+ * of_node (dev.platform_data) and adds it to the list of virtual devices.
+ * Returns a pointer to the created vio_dev or NULL if node has
+ * NULL device_type or compatible fields.
  */
-static const struct vio_device_id *vio_match_device(
-                const struct vio_device_id *ids, const struct vio_dev *dev)
+struct vio_dev * __devinit vio_register_device_node(struct device_node *of_node)
 {
-        while (ids->type[0] != '\0') {
-                if (vio_bus_ops.match(ids, dev))
-                        return ids;
-                ids++;
+        struct vio_dev *viodev;
+        unsigned int *unit_address;
+        unsigned int *irq_p;
+
+        /* we need the 'device_type' property, in order to match with drivers */
+        if (of_node->type == NULL) {
+                printk(KERN_WARNING "%s: node %s missing 'device_type'\n",
+                                __FUNCTION__,
+                                of_node->name ? of_node->name : "<unknown>");
+                return NULL;
         }
-        return NULL;
+
+        unit_address = (unsigned int *)get_property(of_node, "reg", NULL);
+        if (unit_address == NULL) {
+                printk(KERN_WARNING "%s: node %s missing 'reg'\n",
+                                __FUNCTION__,
+                                of_node->name ? of_node->name : "<unknown>");
+                return NULL;
+        }
+
+        /* allocate a vio_dev for this node */
+        viodev = kzalloc(sizeof(struct vio_dev), GFP_KERNEL);
+        if (viodev == NULL)
+                return NULL;
+
+        viodev->dev.platform_data = of_node_get(of_node);
+
+        viodev->irq = NO_IRQ;
+        irq_p = (unsigned int *)get_property(of_node, "interrupts", NULL);
+        if (irq_p) {
+                int virq = virt_irq_create_mapping(*irq_p);
+                if (virq == NO_IRQ) {
+                        printk(KERN_ERR "Unable to allocate interrupt "
+                               "number for %s\n", of_node->full_name);
+                } else
+                        viodev->irq = irq_offset_up(virq);
+        }
+
+        snprintf(viodev->dev.bus_id, BUS_ID_SIZE, "%x", *unit_address);
+        viodev->name = of_node->name;
+        viodev->type = of_node->type;
+        viodev->unit_address = *unit_address;
+        if (firmware_has_feature(FW_FEATURE_ISERIES)) {
+                unit_address = (unsigned int *)get_property(of_node,
+                                "linux,unit_address", NULL);
+                if (unit_address != NULL)
+                        viodev->unit_address = *unit_address;
+        }
+        viodev->iommu_table = vio_build_iommu_table(viodev);
+
+        /* init generic 'struct device' fields: */
+        viodev->dev.parent = &vio_bus_device.dev;
+        viodev->dev.bus = &vio_bus_type;
+        viodev->dev.release = vio_dev_release;
+
+        /* register with generic device framework */
+        if (device_register(&viodev->dev)) {
+                printk(KERN_ERR "%s: failed to register device %s\n",
+                                __FUNCTION__, viodev->dev.bus_id);
+                /* XXX free TCE table */
+                kfree(viodev);
+                return NULL;
+        }
+
+        return viodev;
 }
+EXPORT_SYMBOL(vio_register_device_node);
 
 /**
  * vio_bus_init: - Initialize the virtual IO bus
  */
-int __init vio_bus_init(struct vio_bus_ops *ops)
+static int __init vio_bus_init(void)
 {
         int err;
+        struct device_node *node_vroot;
 
-        vio_bus_ops = *ops;
+#ifdef CONFIG_PPC_ISERIES
+        if (firmware_has_feature(FW_FEATURE_ISERIES)) {
+                iommu_vio_init();
+                vio_bus_device.iommu_table = &vio_iommu_table;
+                iSeries_vio_dev = &vio_bus_device.dev;
+        }
+#endif
 
         err = bus_register(&vio_bus_type);
         if (err) {
@@ -153,47 +317,48 @@ int __init vio_bus_init(struct vio_bus_ops *ops)
                 return err;
         }
 
-        return 0;
-}
+        node_vroot = find_devices("vdevice");
+        if (node_vroot) {
+                struct device_node *of_node;
+
+                /*
+                 * Create struct vio_devices for each virtual device in
+                 * the device tree. Drivers will associate with them later.
+                 */
+                for (of_node = node_vroot->child; of_node != NULL;
+                                of_node = of_node->sibling) {
+                        printk(KERN_DEBUG "%s: processing %p\n",
+                                        __FUNCTION__, of_node);
+                        vio_register_device_node(of_node);
+                }
+        }
 
-/* vio_dev refcount hit 0 */
-static void __devinit vio_dev_release(struct device *dev)
-{
-        if (vio_bus_ops.release_device)
-                vio_bus_ops.release_device(dev);
-        kfree(to_vio_dev(dev));
+        return 0;
 }
+__initcall(vio_bus_init);
 
-static ssize_t viodev_show_name(struct device *dev,
+static ssize_t name_show(struct device *dev,
                 struct device_attribute *attr, char *buf)
 {
         return sprintf(buf, "%s\n", to_vio_dev(dev)->name);
 }
-DEVICE_ATTR(name, S_IRUSR | S_IRGRP | S_IROTH, viodev_show_name, NULL);
 
-struct vio_dev * __devinit vio_register_device(struct vio_dev *viodev)
+static ssize_t devspec_show(struct device *dev,
+                struct device_attribute *attr, char *buf)
 {
-        /* init generic 'struct device' fields: */
-        viodev->dev.parent = &vio_bus_device.dev;
-        viodev->dev.bus = &vio_bus_type;
-        viodev->dev.release = vio_dev_release;
-
-        /* register with generic device framework */
-        if (device_register(&viodev->dev)) {
-                printk(KERN_ERR "%s: failed to register device %s\n",
-                                __FUNCTION__, viodev->dev.bus_id);
-                return NULL;
-        }
-        device_create_file(&viodev->dev, &dev_attr_name);
+        struct device_node *of_node = dev->platform_data;
 
-        return viodev;
+        return sprintf(buf, "%s\n", of_node ? of_node->full_name : "none");
 }
 
+static struct device_attribute vio_dev_attrs[] = {
+        __ATTR_RO(name),
+        __ATTR_RO(devspec),
+        __ATTR_NULL
+};
+
 void __devinit vio_unregister_device(struct vio_dev *viodev)
 {
-        if (vio_bus_ops.unregister_device)
-                vio_bus_ops.unregister_device(viodev);
-        device_remove_file(&viodev->dev, &dev_attr_name);
         device_unregister(&viodev->dev);
 }
 EXPORT_SYMBOL(vio_unregister_device);
@@ -229,7 +394,7 @@ static void *vio_alloc_coherent(struct device *dev, size_t size,
                            dma_addr_t *dma_handle, gfp_t flag)
 {
         return iommu_alloc_coherent(to_vio_dev(dev)->iommu_table, size,
-                        dma_handle, ~0ul, flag);
+                        dma_handle, ~0ul, flag, -1);
 }
 
 static void vio_free_coherent(struct device *dev, size_t size,
@@ -267,22 +432,23 @@ static int vio_hotplug(struct device *dev, char **envp, int num_envp,
                         char *buffer, int buffer_size)
 {
         const struct vio_dev *vio_dev = to_vio_dev(dev);
+        struct device_node *dn = dev->platform_data;
         char *cp;
         int length;
 
         if (!num_envp)
                 return -ENOMEM;
 
-        if (!vio_dev->dev.platform_data)
+        if (!dn)
                 return -ENODEV;
-        cp = (char *)get_property(vio_dev->dev.platform_data, "compatible", &length);
+        cp = (char *)get_property(dn, "compatible", &length);
         if (!cp)
                 return -ENODEV;
 
         envp[0] = buffer;
         length = scnprintf(buffer, buffer_size, "MODALIAS=vio:T%sS%s",
                                 vio_dev->type, cp);
-        if (buffer_size - length <= 0)
+        if ((buffer_size - length) <= 0)
                 return -ENOMEM;
         envp[1] = NULL;
         return 0;
@@ -290,9 +456,81 @@ static int vio_hotplug(struct device *dev, char **envp, int num_envp,
 
 struct bus_type vio_bus_type = {
         .name = "vio",
+        .dev_attrs = vio_dev_attrs,
         .uevent = vio_hotplug,
         .match = vio_bus_match,
         .probe = vio_bus_probe,
         .remove = vio_bus_remove,
         .shutdown = vio_bus_shutdown,
 };
+
+/**
+ * vio_get_attribute: - get attribute for virtual device
+ * @vdev:       The vio device to get property.
+ * @which:      The property/attribute to be extracted.
+ * @length:     Pointer to length of returned data size (unused if NULL).
+ *
+ * Calls prom.c's get_property() to return the value of the
+ * attribute specified by @which
+*/
+const void *vio_get_attribute(struct vio_dev *vdev, char *which, int *length)
+{
+        return get_property(vdev->dev.platform_data, which, length);
+}
+EXPORT_SYMBOL(vio_get_attribute);
+
+#ifdef CONFIG_PPC_PSERIES
+/* vio_find_name() - internal because only vio.c knows how we formatted the
+ * kobject name
+ * XXX once vio_bus_type.devices is actually used as a kset in
+ * drivers/base/bus.c, this function should be removed in favor of
+ * "device_find(kobj_name, &vio_bus_type)"
+ */
+static struct vio_dev *vio_find_name(const char *kobj_name)
+{
+        struct kobject *found;
+
+        found = kset_find_obj(&devices_subsys.kset, kobj_name);
+        if (!found)
+                return NULL;
+
+        return to_vio_dev(container_of(found, struct device, kobj));
+}
+
+/**
+ * vio_find_node - find an already-registered vio_dev
+ * @vnode: device_node of the virtual device we're looking for
+ */
+struct vio_dev *vio_find_node(struct device_node *vnode)
+{
+        uint32_t *unit_address;
+        char kobj_name[BUS_ID_SIZE];
+
+        /* construct the kobject name from the device node */
+        unit_address = (uint32_t *)get_property(vnode, "reg", NULL);
+        if (!unit_address)
+                return NULL;
+        snprintf(kobj_name, BUS_ID_SIZE, "%x", *unit_address);
+
+        return vio_find_name(kobj_name);
+}
+EXPORT_SYMBOL(vio_find_node);
+
+int vio_enable_interrupts(struct vio_dev *dev)
+{
+        int rc = h_vio_signal(dev->unit_address, VIO_IRQ_ENABLE);
+        if (rc != H_SUCCESS)
+                printk(KERN_ERR "vio: Error 0x%x enabling interrupts\n", rc);
+        return rc;
+}
+EXPORT_SYMBOL(vio_enable_interrupts);
+
+int vio_disable_interrupts(struct vio_dev *dev)
+{
+        int rc = h_vio_signal(dev->unit_address, VIO_IRQ_DISABLE);
+        if (rc != H_SUCCESS)
+                printk(KERN_ERR "vio: Error 0x%x disabling interrupts\n", rc);
+        return rc;
+}
+EXPORT_SYMBOL(vio_disable_interrupts);
+#endif /* CONFIG_PPC_PSERIES */
diff --git a/arch/powerpc/kernel/vmlinux.lds.S b/arch/powerpc/kernel/vmlinux.lds.S
index fe79c2584cb0..8b25953dc4f0 100644
--- a/arch/powerpc/kernel/vmlinux.lds.S
+++ b/arch/powerpc/kernel/vmlinux.lds.S
@@ -93,6 +93,11 @@ SECTIONS
                 __ptov_table_begin = .;
                 *(.ptov_fixup);
                 __ptov_table_end = .;
+#ifdef CONFIG_PPC_ISERIES
+                __dt_strings_start = .;
+                *(.dt_strings);
+                __dt_strings_end = .;
+#endif
         }
 
         . = ALIGN(16);
diff --git a/arch/powerpc/lib/Makefile b/arch/powerpc/lib/Makefile
index 34f5c2e074c9..ff7096458249 100644
--- a/arch/powerpc/lib/Makefile
+++ b/arch/powerpc/lib/Makefile
@@ -2,12 +2,15 @@
 # Makefile for ppc-specific library files..
 #
 
+ifeq ($(CONFIG_PPC64),y)
+EXTRA_CFLAGS            += -mno-minimal-toc
+endif
+
 ifeq ($(CONFIG_PPC_MERGE),y)
 obj-y                   := string.o strcase.o
 obj-$(CONFIG_PPC32)     += div64.o copy_32.o checksum_32.o
 endif
 
-obj-y                   += bitops.o
 obj-$(CONFIG_PPC64)     += checksum_64.o copypage_64.o copyuser_64.o \
                            memcpy_64.o usercopy_64.o mem_64.o string.o \
                            strcase.o
diff --git a/arch/powerpc/lib/bitops.c b/arch/powerpc/lib/bitops.c
deleted file mode 100644
index f68ad71a0187..000000000000
--- a/arch/powerpc/lib/bitops.c
+++ /dev/null
@@ -1,150 +0,0 @@
-#include <linux/types.h>
-#include <linux/module.h>
-#include <asm/byteorder.h>
-#include <asm/bitops.h>
-
-/**
- * find_next_bit - find the next set bit in a memory region
- * @addr: The address to base the search on
- * @offset: The bitnumber to start searching at
- * @size: The maximum size to search
- */
-unsigned long find_next_bit(const unsigned long *addr, unsigned long size,
-                            unsigned long offset)
-{
-        const unsigned long *p = addr + BITOP_WORD(offset);
-        unsigned long result = offset & ~(BITS_PER_LONG-1);
-        unsigned long tmp;
-
-        if (offset >= size)
-                return size;
-        size -= result;
-        offset %= BITS_PER_LONG;
-        if (offset) {
-                tmp = *(p++);
-                tmp &= (~0UL << offset);
-                if (size < BITS_PER_LONG)
-                        goto found_first;
-                if (tmp)
-                        goto found_middle;
-                size -= BITS_PER_LONG;
-                result += BITS_PER_LONG;
-        }
-        while (size & ~(BITS_PER_LONG-1)) {
-                if ((tmp = *(p++)))
-                        goto found_middle;
-                result += BITS_PER_LONG;
-                size -= BITS_PER_LONG;
-        }
-        if (!size)
-                return result;
-        tmp = *p;
-
-found_first:
-        tmp &= (~0UL >> (BITS_PER_LONG - size));
-        if (tmp == 0UL)         /* Are any bits set? */
-                return result + size;   /* Nope. */
-found_middle:
-        return result + __ffs(tmp);
-}
-EXPORT_SYMBOL(find_next_bit);
-
-/*
- * This implementation of find_{first,next}_zero_bit was stolen from
- * Linus' asm-alpha/bitops.h.
- */
-unsigned long find_next_zero_bit(const unsigned long *addr, unsigned long size,
-                                 unsigned long offset)
-{
-        const unsigned long *p = addr + BITOP_WORD(offset);
-        unsigned long result = offset & ~(BITS_PER_LONG-1);
-        unsigned long tmp;
-
-        if (offset >= size)
-                return size;
-        size -= result;
-        offset %= BITS_PER_LONG;
-        if (offset) {
-                tmp = *(p++);
-                tmp |= ~0UL >> (BITS_PER_LONG - offset);
-                if (size < BITS_PER_LONG)
-                        goto found_first;
-                if (~tmp)
-                        goto found_middle;
-                size -= BITS_PER_LONG;
-                result += BITS_PER_LONG;
-        }
-        while (size & ~(BITS_PER_LONG-1)) {
-                if (~(tmp = *(p++)))
-                        goto found_middle;
-                result += BITS_PER_LONG;
-                size -= BITS_PER_LONG;
-        }
-        if (!size)
-                return result;
-        tmp = *p;
-
-found_first:
-        tmp |= ~0UL << size;
-        if (tmp == ~0UL)        /* Are any bits zero? */
-                return result + size;   /* Nope. */
-found_middle:
-        return result + ffz(tmp);
-}
-EXPORT_SYMBOL(find_next_zero_bit);
-
-static inline unsigned int ext2_ilog2(unsigned int x)
-{
-        int lz;
-
-        asm("cntlzw %0,%1": "=r"(lz):"r"(x));
-        return 31 - lz;
-}
-
-static inline unsigned int ext2_ffz(unsigned int x)
-{
-        u32 rc;
-        if ((x = ~x) == 0)
-                return 32;
-        rc = ext2_ilog2(x & -x);
-        return rc;
-}
-
-unsigned long find_next_zero_le_bit(const unsigned long *addr,
-                                    unsigned long size, unsigned long offset)
-{
-        const unsigned int *p = ((const unsigned int *)addr) + (offset >> 5);
-        unsigned int result = offset & ~31;
-        unsigned int tmp;
-
-        if (offset >= size)
-                return size;
-        size -= result;
-        offset &= 31;
-        if (offset) {
-                tmp = cpu_to_le32p(p++);
-                tmp |= ~0U >> (32 - offset);    /* bug or feature ? */
-                if (size < 32)
-                        goto found_first;
-                if (tmp != ~0)
-                        goto found_middle;
-                size -= 32;
-                result += 32;
-        }
-        while (size >= 32) {
-                if ((tmp = cpu_to_le32p(p++)) != ~0)
-                        goto found_middle;
-                result += 32;
-                size -= 32;
-        }
-        if (!size)
-                return result;
-        tmp = cpu_to_le32p(p);
-found_first:
-        tmp |= ~0 << size;
-        if (tmp == ~0)          /* Are any bits zero? */
-                return result + size;   /* Nope. */
-found_middle:
-        return result + ext2_ffz(tmp);
-}
-EXPORT_SYMBOL(find_next_zero_le_bit);
diff --git a/arch/powerpc/mm/hash_low_32.S b/arch/powerpc/mm/hash_low_32.S
index ea469eefa146..94255beeecd3 100644
--- a/arch/powerpc/mm/hash_low_32.S
+++ b/arch/powerpc/mm/hash_low_32.S
@@ -74,12 +74,6 @@ _GLOBAL(hash_page_sync)
  */
         .text
 _GLOBAL(hash_page)
-#ifdef CONFIG_PPC64BRIDGE
-        mfmsr   r0
-        clrldi  r0,r0,1         /* make sure it's in 32-bit mode */
-        MTMSRD(r0)
-        isync
-#endif
         tophys(r7,0)                    /* gets -KERNELBASE into r7 */
 #ifdef CONFIG_SMP
         addis   r8,r7,mmu_hash_lock@h
@@ -285,7 +279,6 @@ Hash_base = 0xc0180000
 Hash_bits = 12                          /* e.g. 256kB hash table */
 Hash_msk = (((1 << Hash_bits) - 1) * 64)
 
-#ifndef CONFIG_PPC64BRIDGE
 /* defines for the PTE format for 32-bit PPCs */
 #define PTE_SIZE        8
 #define PTEG_SIZE       64
@@ -299,21 +292,6 @@ Hash_msk = (((1 << Hash_bits) - 1) * 64)
 #define SET_V(r)        oris r,r,PTE_V@h
 #define CLR_V(r,t)      rlwinm r,r,0,1,31
 
-#else
-/* defines for the PTE format for 64-bit PPCs */
-#define PTE_SIZE        16
-#define PTEG_SIZE       128
-#define LG_PTEG_SIZE    7
-#define LDPTEu          ldu
-#define STPTE           std
-#define CMPPTE          cmpd
-#define PTE_H           2
-#define PTE_V           1
-#define TST_V(r)        andi. r,r,PTE_V
-#define SET_V(r)        ori r,r,PTE_V
-#define CLR_V(r,t)      li t,PTE_V; andc r,r,t
-#endif /* CONFIG_PPC64BRIDGE */
-
 #define HASH_LEFT       31-(LG_PTEG_SIZE+Hash_bits-1)
 #define HASH_RIGHT      31-LG_PTEG_SIZE
 
@@ -331,14 +309,8 @@ BEGIN_FTR_SECTION
 END_FTR_SECTION_IFSET(CPU_FTR_NEED_COHERENT)
 
         /* Construct the high word of the PPC-style PTE (r5) */
-#ifndef CONFIG_PPC64BRIDGE
         rlwinm  r5,r3,7,1,24            /* put VSID in 0x7fffff80 bits */
         rlwimi  r5,r4,10,26,31          /* put in API (abbrev page index) */
-#else /* CONFIG_PPC64BRIDGE */
-        clrlwi  r3,r3,8                 /* reduce vsid to 24 bits */
-        sldi    r5,r3,12                /* shift vsid into position */
-        rlwimi  r5,r4,16,20,24          /* put in API (abbrev page index) */
-#endif /* CONFIG_PPC64BRIDGE */
         SET_V(r5)                       /* set V (valid) bit */
 
         /* Get the address of the primary PTE group in the hash table (r3) */
@@ -516,14 +488,8 @@ _GLOBAL(flush_hash_pages)
         add     r3,r3,r0                /* note code below trims to 24 bits */
 
         /* Construct the high word of the PPC-style PTE (r11) */
-#ifndef CONFIG_PPC64BRIDGE
         rlwinm  r11,r3,7,1,24           /* put VSID in 0x7fffff80 bits */
         rlwimi  r11,r4,10,26,31         /* put in API (abbrev page index) */
-#else /* CONFIG_PPC64BRIDGE */
-        clrlwi  r3,r3,8                 /* reduce vsid to 24 bits */
-        sldi    r11,r3,12               /* shift vsid into position */
-        rlwimi  r11,r4,16,20,24         /* put in API (abbrev page index) */
-#endif /* CONFIG_PPC64BRIDGE */
         SET_V(r11)                      /* set V (valid) bit */
 
 #ifdef CONFIG_SMP
diff --git a/arch/powerpc/mm/hash_low_64.S b/arch/powerpc/mm/hash_low_64.S
index e0d02c4a2615..52e914238959 100644
--- a/arch/powerpc/mm/hash_low_64.S
+++ b/arch/powerpc/mm/hash_low_64.S
@@ -136,6 +136,7 @@ _GLOBAL(__hash_page_4K)
         and     r0,r0,r4                /* _PAGE_RW & _PAGE_DIRTY ->r0 bit 30*/
         andc    r0,r30,r0               /* r0 = pte & ~r0 */
         rlwimi  r3,r0,32-1,31,31        /* Insert result into PP lsb */
+        ori     r3,r3,HPTE_R_C          /* Always add "C" bit for perf. */
 
         /* We eventually do the icache sync here (maybe inline that
          * code rather than call a C function...) 
@@ -368,6 +369,7 @@ _GLOBAL(__hash_page_4K)
         rlwinm  r30,r4,32-9+7,31-7,31-7 /* _PAGE_RW -> _PAGE_DIRTY */
         or      r30,r30,r31
         ori     r30,r30,_PAGE_BUSY | _PAGE_ACCESSED | _PAGE_HASHPTE
+        oris    r30,r30,_PAGE_COMBO@h
         /* Write the linux PTE atomically (setting busy) */
         stdcx.  r30,0,r6
         bne-    1b
@@ -400,6 +402,7 @@ _GLOBAL(__hash_page_4K)
         and     r0,r0,r4                /* _PAGE_RW & _PAGE_DIRTY ->r0 bit 30*/
         andc    r0,r30,r0               /* r0 = pte & ~r0 */
         rlwimi  r3,r0,32-1,31,31        /* Insert result into PP lsb */
+        ori     r3,r3,HPTE_R_C          /* Always add "C" bit for perf. */
 
         /* We eventually do the icache sync here (maybe inline that
          * code rather than call a C function...)
@@ -426,6 +429,14 @@ END_FTR_SECTION(CPU_FTR_NOEXECUTE|CPU_FTR_COHERENT_ICACHE, CPU_FTR_NOEXECUTE)
         andi.   r0,r31,_PAGE_HASHPTE
         li      r26,0                   /* Default hidx */
         beq     htab_insert_pte
+
+        /*
+         * Check if the pte was already inserted into the hash table
+         * as a 64k HW page, and invalidate the 64k HPTE if so.
+         */
+        andis.  r0,r31,_PAGE_COMBO@h
+        beq     htab_inval_old_hpte
+
         ld      r6,STK_PARM(r6)(r1)
         ori     r26,r6,0x8000           /* Load the hidx mask */
         ld      r26,0(r26)
@@ -496,6 +507,19 @@ _GLOBAL(htab_call_hpte_remove)
         /* Try all again */
         b       htab_insert_pte
 
+        /*
+         * Call out to C code to invalidate an 64k HW HPTE that is
+         * useless now that the segment has been switched to 4k pages.
+         */
+htab_inval_old_hpte:
+        mr      r3,r29                  /* virtual addr */
+        mr      r4,r31                  /* PTE.pte */
+        li      r5,0                    /* PTE.hidx */
+        li      r6,MMU_PAGE_64K         /* psize */
+        ld      r7,STK_PARM(r8)(r1)     /* local */
+        bl      .flush_hash_page
+        b       htab_insert_pte
+        
 htab_bail_ok:
         li      r3,0
         b       htab_bail
@@ -636,6 +660,12 @@ _GLOBAL(__hash_page_64K)
          * is changing this PTE anyway and might hash it.
          */
         bne-    ht64_bail_ok
+BEGIN_FTR_SECTION
+        /* Check if PTE has the cache-inhibit bit set */
+        andi.   r0,r31,_PAGE_NO_CACHE
+        /* If so, bail out and refault as a 4k page */
+        bne-    ht64_bail_ok
+END_FTR_SECTION_IFCLR(CPU_FTR_CI_LARGE_PAGE)
         /* Prepare new PTE value (turn access RW into DIRTY, then
          * add BUSY,HASHPTE and ACCESSED)
          */
@@ -671,6 +701,7 @@ _GLOBAL(__hash_page_64K)
         and     r0,r0,r4                /* _PAGE_RW & _PAGE_DIRTY ->r0 bit 30*/
         andc    r0,r30,r0               /* r0 = pte & ~r0 */
         rlwimi  r3,r0,32-1,31,31        /* Insert result into PP lsb */
+        ori     r3,r3,HPTE_R_C          /* Always add "C" bit for perf. */
 
         /* We eventually do the icache sync here (maybe inline that
          * code rather than call a C function...)
diff --git a/arch/powerpc/mm/hash_native_64.c b/arch/powerpc/mm/hash_native_64.c
index 994856e55b7c..a0f3cbd00d39 100644
--- a/arch/powerpc/mm/hash_native_64.c
+++ b/arch/powerpc/mm/hash_native_64.c
@@ -238,7 +238,7 @@ static long native_hpte_updatepp(unsigned long slot, unsigned long newpp,
                 DBG_LOW(" -> hit\n");
                 /* Update the HPTE */
                 hptep->r = (hptep->r & ~(HPTE_R_PP | HPTE_R_N)) |
-                        (newpp & (HPTE_R_PP | HPTE_R_N));
+                        (newpp & (HPTE_R_PP | HPTE_R_N | HPTE_R_C));
                 native_unlock_hpte(hptep);
         }
 
diff --git a/arch/powerpc/mm/hash_utils_64.c b/arch/powerpc/mm/hash_utils_64.c
index c006d9039633..d03fd2b4445e 100644
--- a/arch/powerpc/mm/hash_utils_64.c
+++ b/arch/powerpc/mm/hash_utils_64.c
@@ -92,10 +92,15 @@ unsigned long htab_size_bytes;
 unsigned long htab_hash_mask;
 int mmu_linear_psize = MMU_PAGE_4K;
 int mmu_virtual_psize = MMU_PAGE_4K;
+int mmu_vmalloc_psize = MMU_PAGE_4K;
+int mmu_io_psize = MMU_PAGE_4K;
 #ifdef CONFIG_HUGETLB_PAGE
 int mmu_huge_psize = MMU_PAGE_16M;
 unsigned int HPAGE_SHIFT;
 #endif
+#ifdef CONFIG_PPC_64K_PAGES
+int mmu_ci_restrictions;
+#endif
 
 /* There are definitions of page sizes arrays to be used when none
  * is provided by the firmware.
@@ -308,20 +313,31 @@ static void __init htab_init_page_sizes(void)
         else if (mmu_psize_defs[MMU_PAGE_1M].shift)
                 mmu_linear_psize = MMU_PAGE_1M;
 
+#ifdef CONFIG_PPC_64K_PAGES
         /*
          * Pick a size for the ordinary pages. Default is 4K, we support
-         * 64K if cache inhibited large pages are supported by the
-         * processor
+         * 64K for user mappings and vmalloc if supported by the processor.
+         * We only use 64k for ioremap if the processor
+         * (and firmware) support cache-inhibited large pages.
+         * If not, we use 4k and set mmu_ci_restrictions so that
+         * hash_page knows to switch processes that use cache-inhibited
+         * mappings to 4k pages.
          */
-#ifdef CONFIG_PPC_64K_PAGES
-        if (mmu_psize_defs[MMU_PAGE_64K].shift &&
-            cpu_has_feature(CPU_FTR_CI_LARGE_PAGE))
+        if (mmu_psize_defs[MMU_PAGE_64K].shift) {
                 mmu_virtual_psize = MMU_PAGE_64K;
+                mmu_vmalloc_psize = MMU_PAGE_64K;
+                if (cpu_has_feature(CPU_FTR_CI_LARGE_PAGE))
+                        mmu_io_psize = MMU_PAGE_64K;
+                else
+                        mmu_ci_restrictions = 1;
+        }
 #endif
 
-        printk(KERN_INFO "Page orders: linear mapping = %d, others = %d\n",
+        printk(KERN_DEBUG "Page orders: linear mapping = %d, "
+               "virtual = %d, io = %d\n",
                mmu_psize_defs[mmu_linear_psize].shift,
-               mmu_psize_defs[mmu_virtual_psize].shift);
+               mmu_psize_defs[mmu_virtual_psize].shift,
+               mmu_psize_defs[mmu_io_psize].shift);
 
 #ifdef CONFIG_HUGETLB_PAGE
         /* Init large page size. Currently, we pick 16M or 1M depending
@@ -556,6 +572,7 @@ int hash_page(unsigned long ea, unsigned long access, unsigned long trap)
         pte_t *ptep;
         cpumask_t tmp;
         int rc, user_region = 0, local = 0;
+        int psize;
 
         DBG_LOW("hash_page(ea=%016lx, access=%lx, trap=%lx\n",
                 ea, access, trap);
@@ -575,10 +592,15 @@ int hash_page(unsigned long ea, unsigned long access, unsigned long trap)
                         return 1;
                 }
                 vsid = get_vsid(mm->context.id, ea);
+                psize = mm->context.user_psize;
                 break;
         case VMALLOC_REGION_ID:
                 mm = &init_mm;
                 vsid = get_kernel_vsid(ea);
+                if (ea < VMALLOC_END)
+                        psize = mmu_vmalloc_psize;
+                else
+                        psize = mmu_io_psize;
                 break;
         default:
                 /* Not a valid range
@@ -629,7 +651,40 @@ int hash_page(unsigned long ea, unsigned long access, unsigned long trap)
 #ifndef CONFIG_PPC_64K_PAGES
         rc = __hash_page_4K(ea, access, vsid, ptep, trap, local);
 #else
-        if (mmu_virtual_psize == MMU_PAGE_64K)
+        if (mmu_ci_restrictions) {
+                /* If this PTE is non-cacheable, switch to 4k */
+                if (psize == MMU_PAGE_64K &&
+                    (pte_val(*ptep) & _PAGE_NO_CACHE)) {
+                        if (user_region) {
+                                psize = MMU_PAGE_4K;
+                                mm->context.user_psize = MMU_PAGE_4K;
+                                mm->context.sllp = SLB_VSID_USER |
+                                        mmu_psize_defs[MMU_PAGE_4K].sllp;
+                        } else if (ea < VMALLOC_END) {
+                                /*
+                                 * some driver did a non-cacheable mapping
+                                 * in vmalloc space, so switch vmalloc
+                                 * to 4k pages
+                                 */
+                                printk(KERN_ALERT "Reducing vmalloc segment "
+                                       "to 4kB pages because of "
+                                       "non-cacheable mapping\n");
+                                psize = mmu_vmalloc_psize = MMU_PAGE_4K;
+                        }
+                }
+                if (user_region) {
+                        if (psize != get_paca()->context.user_psize) {
+                                get_paca()->context = mm->context;
+                                slb_flush_and_rebolt();
+                        }
+                } else if (get_paca()->vmalloc_sllp !=
+                           mmu_psize_defs[mmu_vmalloc_psize].sllp) {
+                        get_paca()->vmalloc_sllp =
+                                mmu_psize_defs[mmu_vmalloc_psize].sllp;
+                        slb_flush_and_rebolt();
+                }
+        }
+        if (psize == MMU_PAGE_64K)
                 rc = __hash_page_64K(ea, access, vsid, ptep, trap, local);
         else
                 rc = __hash_page_4K(ea, access, vsid, ptep, trap, local);
@@ -681,7 +736,18 @@ void hash_preload(struct mm_struct *mm, unsigned long ea,
 #ifndef CONFIG_PPC_64K_PAGES
         __hash_page_4K(ea, access, vsid, ptep, trap, local);
 #else
-        if (mmu_virtual_psize == MMU_PAGE_64K)
+        if (mmu_ci_restrictions) {
+                /* If this PTE is non-cacheable, switch to 4k */
+                if (mm->context.user_psize == MMU_PAGE_64K &&
+                    (pte_val(*ptep) & _PAGE_NO_CACHE)) {
+                        mm->context.user_psize = MMU_PAGE_4K;
+                        mm->context.sllp = SLB_VSID_USER |
+                                mmu_psize_defs[MMU_PAGE_4K].sllp;
+                        get_paca()->context = mm->context;
+                        slb_flush_and_rebolt();
+                }
+        }
+        if (mm->context.user_psize == MMU_PAGE_64K)
                 __hash_page_64K(ea, access, vsid, ptep, trap, local);
         else
                 __hash_page_4K(ea, access, vsid, ptep, trap, local);
diff --git a/arch/powerpc/mm/lmb.c b/arch/powerpc/mm/lmb.c
index 417d58518558..8b6f522655a6 100644
--- a/arch/powerpc/mm/lmb.c
+++ b/arch/powerpc/mm/lmb.c
@@ -89,20 +89,25 @@ static long __init lmb_regions_adjacent(struct lmb_region *rgn,
         return lmb_addrs_adjacent(base1, size1, base2, size2);
 }
 
-/* Assumption: base addr of region 1 < base addr of region 2 */
-static void __init lmb_coalesce_regions(struct lmb_region *rgn,
-                unsigned long r1, unsigned long r2)
+static void __init lmb_remove_region(struct lmb_region *rgn, unsigned long r)
 {
         unsigned long i;
 
-        rgn->region[r1].size += rgn->region[r2].size;
-        for (i=r2; i < rgn->cnt-1; i++) {
-                rgn->region[i].base = rgn->region[i+1].base;
-                rgn->region[i].size = rgn->region[i+1].size;
+        for (i = r; i < rgn->cnt - 1; i++) {
+                rgn->region[i].base = rgn->region[i + 1].base;
+                rgn->region[i].size = rgn->region[i + 1].size;
         }
         rgn->cnt--;
 }
 
+/* Assumption: base addr of region 1 < base addr of region 2 */
+static void __init lmb_coalesce_regions(struct lmb_region *rgn,
+                unsigned long r1, unsigned long r2)
+{
+        rgn->region[r1].size += rgn->region[r2].size;
+        lmb_remove_region(rgn, r2);
+}
+
 /* This routine called with relocation disabled. */
 void __init lmb_init(void)
 {
@@ -294,17 +299,16 @@ unsigned long __init lmb_end_of_DRAM(void)
         return (lmb.memory.region[idx].base + lmb.memory.region[idx].size);
 }
 
-/*
- * Truncate the lmb list to memory_limit if it's set
- * You must call lmb_analyze() after this.
- */
+/* You must call lmb_analyze() after this. */
 void __init lmb_enforce_memory_limit(unsigned long memory_limit)
 {
         unsigned long i, limit;
+        struct lmb_property *p;
 
         if (! memory_limit)
                 return;
 
+        /* Truncate the lmb regions to satisfy the memory limit. */
         limit = memory_limit;
         for (i = 0; i < lmb.memory.cnt; i++) {
                 if (limit > lmb.memory.region[i].size) {
@@ -316,4 +320,21 @@ void __init lmb_enforce_memory_limit(unsigned long memory_limit)
                 lmb.memory.cnt = i + 1;
                 break;
         }
+
+        lmb.rmo_size = lmb.memory.region[0].size;
+
+        /* And truncate any reserves above the limit also. */
+        for (i = 0; i < lmb.reserved.cnt; i++) {
+                p = &lmb.reserved.region[i];
+
+                if (p->base > memory_limit)
+                        p->size = 0;
+                else if ((p->base + p->size) > memory_limit)
+                        p->size = memory_limit - p->base;
+
+                if (p->size == 0) {
+                        lmb_remove_region(&lmb.reserved, i);
+                        i--;
+                }
+        }
 }
diff --git a/arch/powerpc/mm/mem.c b/arch/powerpc/mm/mem.c
index 741dd8802d49..69f3b9a20beb 100644
--- a/arch/powerpc/mm/mem.c
+++ b/arch/powerpc/mm/mem.c
@@ -299,9 +299,9 @@ void __init paging_init(void)
         kmap_prot = PAGE_KERNEL;
 #endif /* CONFIG_HIGHMEM */
 
-        printk(KERN_INFO "Top of RAM: 0x%lx, Total RAM: 0x%lx\n",
+        printk(KERN_DEBUG "Top of RAM: 0x%lx, Total RAM: 0x%lx\n",
                top_of_ram, total_ram);
-        printk(KERN_INFO "Memory hole size: %ldMB\n",
+        printk(KERN_DEBUG "Memory hole size: %ldMB\n",
                (top_of_ram - total_ram) >> 20);
         /*
          * All pages are DMA-able so we put them all in the DMA zone.
@@ -380,7 +380,7 @@ void __init mem_init(void)
                         totalhigh_pages++;
                 }
                 totalram_pages += totalhigh_pages;
-                printk(KERN_INFO "High memory: %luk\n",
+                printk(KERN_DEBUG "High memory: %luk\n",
                        totalhigh_pages << (PAGE_SHIFT-10));
         }
 #endif /* CONFIG_HIGHMEM */
diff --git a/arch/powerpc/mm/mmu_context_32.c b/arch/powerpc/mm/mmu_context_32.c
index a8816e0f6a86..e326e4249e1a 100644
--- a/arch/powerpc/mm/mmu_context_32.c
+++ b/arch/powerpc/mm/mmu_context_32.c
@@ -30,7 +30,7 @@
 #include <asm/mmu_context.h>
 #include <asm/tlbflush.h>
 
-mm_context_t next_mmu_context;
+unsigned long next_mmu_context;
 unsigned long context_map[LAST_CONTEXT / BITS_PER_LONG + 1];
 #ifdef FEW_CONTEXTS
 atomic_t nr_free_contexts;
diff --git a/arch/powerpc/mm/mmu_context_64.c b/arch/powerpc/mm/mmu_context_64.c
index 714a84dd8d5d..65d18dca266f 100644
--- a/arch/powerpc/mm/mmu_context_64.c
+++ b/arch/powerpc/mm/mmu_context_64.c
@@ -49,6 +49,9 @@ again:
         }
 
         mm->context.id = index;
+        mm->context.user_psize = mmu_virtual_psize;
+        mm->context.sllp = SLB_VSID_USER |
+                mmu_psize_defs[mmu_virtual_psize].sllp;
 
         return 0;
 }
diff --git a/arch/powerpc/mm/numa.c b/arch/powerpc/mm/numa.c
index 092355f37399..aa98cb3b59d8 100644
--- a/arch/powerpc/mm/numa.c
+++ b/arch/powerpc/mm/numa.c
@@ -487,9 +487,9 @@ static void __init setup_nonnuma(void)
         unsigned long total_ram = lmb_phys_mem_size();
         unsigned int i;
 
-        printk(KERN_INFO "Top of RAM: 0x%lx, Total RAM: 0x%lx\n",
+        printk(KERN_DEBUG "Top of RAM: 0x%lx, Total RAM: 0x%lx\n",
                top_of_ram, total_ram);
-        printk(KERN_INFO "Memory hole size: %ldMB\n",
+        printk(KERN_DEBUG "Memory hole size: %ldMB\n",
                (top_of_ram - total_ram) >> 20);
 
         for (i = 0; i < lmb.memory.cnt; ++i)
@@ -507,7 +507,7 @@ void __init dump_numa_cpu_topology(void)
                 return;
 
         for_each_online_node(node) {
-                printk(KERN_INFO "Node %d CPUs:", node);
+                printk(KERN_DEBUG "Node %d CPUs:", node);
 
                 count = 0;
                 /*
@@ -543,7 +543,7 @@ static void __init dump_numa_memory_topology(void)
         for_each_online_node(node) {
                 unsigned long i;
 
-                printk(KERN_INFO "Node %d Memory:", node);
+                printk(KERN_DEBUG "Node %d Memory:", node);
 
                 count = 0;
 
diff --git a/arch/powerpc/mm/ppc_mmu_32.c b/arch/powerpc/mm/ppc_mmu_32.c
index ed7fcfe5fd37..2ed43a493b31 100644
--- a/arch/powerpc/mm/ppc_mmu_32.c
+++ b/arch/powerpc/mm/ppc_mmu_32.c
@@ -42,18 +42,14 @@ unsigned long _SDR1;
 
 union ubat {                    /* BAT register values to be loaded */
         BAT     bat;
-#ifdef CONFIG_PPC64BRIDGE
-        u64     word[2];
-#else
         u32     word[2];
-#endif
-} BATS[4][2];                   /* 4 pairs of IBAT, DBAT */
+} BATS[8][2];                   /* 8 pairs of IBAT, DBAT */
 
 struct batrange {               /* stores address ranges mapped by BATs */
         unsigned long start;
         unsigned long limit;
         unsigned long phys;
-} bat_addrs[4];
+} bat_addrs[8];
 
 /*
  * Return PA for this VA if it is mapped by a BAT, or 0
@@ -190,7 +186,7 @@ void hash_preload(struct mm_struct *mm, unsigned long ea,
                 return;
         pmd = pmd_offset(pgd_offset(mm, ea), ea);
         if (!pmd_none(*pmd))
-                add_hash_page(mm->context, ea, pmd_val(*pmd));
+                add_hash_page(mm->context.id, ea, pmd_val(*pmd));
 }
 
 /*
@@ -220,15 +216,9 @@ void __init MMU_init_hw(void)
 
         if ( ppc_md.progress ) ppc_md.progress("hash:enter", 0x105);
 
-#ifdef CONFIG_PPC64BRIDGE
-#define LG_HPTEG_SIZE   7               /* 128 bytes per HPTEG */
-#define SDR1_LOW_BITS   (lg_n_hpteg - 11)
-#define MIN_N_HPTEG     2048            /* min 256kB hash table */
-#else
 #define LG_HPTEG_SIZE   6               /* 64 bytes per HPTEG */
 #define SDR1_LOW_BITS   ((n_hpteg - 1) >> 10)
 #define MIN_N_HPTEG     1024            /* min 64kB hash table */
-#endif
 
         /*
          * Allow 1 HPTE (1/8 HPTEG) for each page of memory.
diff --git a/arch/powerpc/mm/slb.c b/arch/powerpc/mm/slb.c
index ffc8ed4de62d..6a8bf6c6000e 100644
--- a/arch/powerpc/mm/slb.c
+++ b/arch/powerpc/mm/slb.c
@@ -60,19 +60,19 @@ static inline void create_slbe(unsigned long ea, unsigned long flags,
                      : "memory" );
 }
 
-static void slb_flush_and_rebolt(void)
+void slb_flush_and_rebolt(void)
 {
         /* If you change this make sure you change SLB_NUM_BOLTED
          * appropriately too. */
-        unsigned long linear_llp, virtual_llp, lflags, vflags;
+        unsigned long linear_llp, vmalloc_llp, lflags, vflags;
         unsigned long ksp_esid_data;
 
         WARN_ON(!irqs_disabled());
 
         linear_llp = mmu_psize_defs[mmu_linear_psize].sllp;
-        virtual_llp = mmu_psize_defs[mmu_virtual_psize].sllp;
+        vmalloc_llp = mmu_psize_defs[mmu_vmalloc_psize].sllp;
         lflags = SLB_VSID_KERNEL | linear_llp;
-        vflags = SLB_VSID_KERNEL | virtual_llp;
+        vflags = SLB_VSID_KERNEL | vmalloc_llp;
 
         ksp_esid_data = mk_esid_data(get_paca()->kstack, 2);
         if ((ksp_esid_data & ESID_MASK) == PAGE_OFFSET)
@@ -122,9 +122,6 @@ void switch_slb(struct task_struct *tsk, struct mm_struct *mm)
 
         get_paca()->slb_cache_ptr = 0;
         get_paca()->context = mm->context;
-#ifdef CONFIG_PPC_64K_PAGES
-        get_paca()->pgdir = mm->pgd;
-#endif /* CONFIG_PPC_64K_PAGES */
 
         /*
          * preload some userspace segments into the SLB.
@@ -167,11 +164,10 @@ static inline void patch_slb_encoding(unsigned int *insn_addr,
 
 void slb_initialize(void)
 {
-        unsigned long linear_llp, virtual_llp;
+        unsigned long linear_llp, vmalloc_llp, io_llp;
         static int slb_encoding_inited;
         extern unsigned int *slb_miss_kernel_load_linear;
-        extern unsigned int *slb_miss_kernel_load_virtual;
-        extern unsigned int *slb_miss_user_load_normal;
+        extern unsigned int *slb_miss_kernel_load_io;
 #ifdef CONFIG_HUGETLB_PAGE
         extern unsigned int *slb_miss_user_load_huge;
         unsigned long huge_llp;
@@ -181,18 +177,19 @@ void slb_initialize(void)
 
         /* Prepare our SLB miss handler based on our page size */
         linear_llp = mmu_psize_defs[mmu_linear_psize].sllp;
-        virtual_llp = mmu_psize_defs[mmu_virtual_psize].sllp;
+        io_llp = mmu_psize_defs[mmu_io_psize].sllp;
+        vmalloc_llp = mmu_psize_defs[mmu_vmalloc_psize].sllp;
+        get_paca()->vmalloc_sllp = SLB_VSID_KERNEL | vmalloc_llp;
+
         if (!slb_encoding_inited) {
                 slb_encoding_inited = 1;
                 patch_slb_encoding(slb_miss_kernel_load_linear,
                                    SLB_VSID_KERNEL | linear_llp);
-                patch_slb_encoding(slb_miss_kernel_load_virtual,
-                                   SLB_VSID_KERNEL | virtual_llp);
-                patch_slb_encoding(slb_miss_user_load_normal,
-                                   SLB_VSID_USER | virtual_llp);
+                patch_slb_encoding(slb_miss_kernel_load_io,
+                                   SLB_VSID_KERNEL | io_llp);
 
                 DBG("SLB: linear  LLP = %04x\n", linear_llp);
-                DBG("SLB: virtual LLP = %04x\n", virtual_llp);
+                DBG("SLB: io      LLP = %04x\n", io_llp);
 #ifdef CONFIG_HUGETLB_PAGE
                 patch_slb_encoding(slb_miss_user_load_huge,
                                    SLB_VSID_USER | huge_llp);
@@ -207,7 +204,7 @@ void slb_initialize(void)
         unsigned long lflags, vflags;
 
         lflags = SLB_VSID_KERNEL | linear_llp;
-        vflags = SLB_VSID_KERNEL | virtual_llp;
+        vflags = SLB_VSID_KERNEL | vmalloc_llp;
 
         /* Invalidate the entire SLB (even slot 0) & all the ERATS */
         asm volatile("isync":::"memory");
@@ -215,7 +212,6 @@ void slb_initialize(void)
         asm volatile("isync; slbia; isync":::"memory");
         create_slbe(PAGE_OFFSET, lflags, 0);
 
-        /* VMALLOC space has 4K pages always for now */
         create_slbe(VMALLOC_START, vflags, 1);
 
         /* We don't bolt the stack for the time being - we're in boot,
diff --git a/arch/powerpc/mm/slb_low.S b/arch/powerpc/mm/slb_low.S
index abfaabf667bf..8548dcf8ef8b 100644
--- a/arch/powerpc/mm/slb_low.S
+++ b/arch/powerpc/mm/slb_low.S
@@ -59,10 +59,19 @@ _GLOBAL(slb_miss_kernel_load_linear)
         li      r11,0
         b       slb_finish_load
 
-1:      /* vmalloc/ioremap mapping encoding bits, the "li" instruction below
+1:      /* vmalloc/ioremap mapping encoding bits, the "li" instructions below
          * will be patched by the kernel at boot
          */
-_GLOBAL(slb_miss_kernel_load_virtual)
+BEGIN_FTR_SECTION
+        /* check whether this is in vmalloc or ioremap space */
+        clrldi  r11,r10,48
+        cmpldi  r11,(VMALLOC_SIZE >> 28) - 1
+        bgt     5f
+        lhz     r11,PACAVMALLOCSLLP(r13)
+        b       slb_finish_load
+5:
+END_FTR_SECTION_IFCLR(CPU_FTR_CI_LARGE_PAGE)
+_GLOBAL(slb_miss_kernel_load_io)
         li      r11,0
         b       slb_finish_load
 
@@ -96,9 +105,7 @@ _GLOBAL(slb_miss_user_load_huge)
 1:
 #endif /* CONFIG_HUGETLB_PAGE */
 
-_GLOBAL(slb_miss_user_load_normal)
-        li      r11,0
-
+        lhz     r11,PACACONTEXTSLLP(r13)
 2:
         ld      r9,PACACONTEXTID(r13)
         rldimi  r10,r9,USER_ESID_BITS,0
diff --git a/arch/powerpc/mm/stab.c b/arch/powerpc/mm/stab.c
index 4a9291d9fef8..691320c90b78 100644
--- a/arch/powerpc/mm/stab.c
+++ b/arch/powerpc/mm/stab.c
@@ -200,10 +200,6 @@ void switch_stab(struct task_struct *tsk, struct mm_struct *mm)
 
         __get_cpu_var(stab_cache_ptr) = 0;
 
-#ifdef CONFIG_PPC_64K_PAGES
-        get_paca()->pgdir = mm->pgd;
-#endif /* CONFIG_PPC_64K_PAGES */
-
         /* Now preload some entries for the new task */
         if (test_tsk_thread_flag(tsk, TIF_32BIT))
                 unmapped_base = TASK_UNMAPPED_BASE_USER32;
diff --git a/arch/powerpc/mm/tlb_32.c b/arch/powerpc/mm/tlb_32.c
index ad580f3742e5..02eb23e036d5 100644
--- a/arch/powerpc/mm/tlb_32.c
+++ b/arch/powerpc/mm/tlb_32.c
@@ -42,7 +42,7 @@ void flush_hash_entry(struct mm_struct *mm, pte_t *ptep, unsigned long addr)
 
         if (Hash != 0) {
                 ptephys = __pa(ptep) & PAGE_MASK;
-                flush_hash_pages(mm->context, addr, ptephys, 1);
+                flush_hash_pages(mm->context.id, addr, ptephys, 1);
         }
 }
 
@@ -102,7 +102,7 @@ static void flush_range(struct mm_struct *mm, unsigned long start,
         pmd_t *pmd;
         unsigned long pmd_end;
         int count;
-        unsigned int ctx = mm->context;
+        unsigned int ctx = mm->context.id;
 
         if (Hash == 0) {
                 _tlbia();
@@ -172,7 +172,7 @@ void flush_tlb_page(struct vm_area_struct *vma, unsigned long vmaddr)
         mm = (vmaddr < TASK_SIZE)? vma->vm_mm: &init_mm;
         pmd = pmd_offset(pgd_offset(mm, vmaddr), vmaddr);
         if (!pmd_none(*pmd))
-                flush_hash_pages(mm->context, vmaddr, pmd_val(*pmd), 1);
+                flush_hash_pages(mm->context.id, vmaddr, pmd_val(*pmd), 1);
         FINISH_FLUSH;
 }
 
diff --git a/arch/powerpc/mm/tlb_64.c b/arch/powerpc/mm/tlb_64.c
index f734b11566c2..e7449b068c82 100644
--- a/arch/powerpc/mm/tlb_64.c
+++ b/arch/powerpc/mm/tlb_64.c
@@ -131,7 +131,7 @@ void hpte_update(struct mm_struct *mm, unsigned long addr,
 {
         struct ppc64_tlb_batch *batch = &__get_cpu_var(ppc64_tlb_batch);
         unsigned long vsid;
-        unsigned int psize = mmu_virtual_psize;
+        unsigned int psize;
         int i;
 
         i = batch->index;
@@ -148,7 +148,8 @@ void hpte_update(struct mm_struct *mm, unsigned long addr,
 #else
                 BUG();
 #endif
-        }
+        } else
+                psize = pte_pagesize_index(pte);
 
         /*
          * This can happen when we are in the middle of a TLB batch and
diff --git a/arch/powerpc/oprofile/Kconfig b/arch/powerpc/oprofile/Kconfig
index d03c0e5ca870..eb2dece76a54 100644
--- a/arch/powerpc/oprofile/Kconfig
+++ b/arch/powerpc/oprofile/Kconfig
@@ -1,5 +1,4 @@
 config PROFILING
-        depends on !PPC_ISERIES
         bool "Profiling support (EXPERIMENTAL)"
         help
           Say Y here to enable the extended profiling support mechanisms used
diff --git a/arch/powerpc/oprofile/Makefile b/arch/powerpc/oprofile/Makefile
index f5f9859a8338..3145d610b5b0 100644
--- a/arch/powerpc/oprofile/Makefile
+++ b/arch/powerpc/oprofile/Makefile
@@ -1,3 +1,7 @@
+ifeq ($(CONFIG_PPC64),y)
+EXTRA_CFLAGS    += -mno-minimal-toc
+endif
+
 obj-$(CONFIG_OPROFILE) += oprofile.o
 
 DRIVER_OBJS := $(addprefix ../../../drivers/oprofile/, \
diff --git a/arch/powerpc/oprofile/common.c b/arch/powerpc/oprofile/common.c
index 5b1de7e8041e..27ad56bd227e 100644
--- a/arch/powerpc/oprofile/common.c
+++ b/arch/powerpc/oprofile/common.c
@@ -22,6 +22,7 @@
 #include <asm/pmc.h>
 #include <asm/cputable.h>
 #include <asm/oprofile_impl.h>
+#include <asm/firmware.h>
 
 static struct op_powerpc_model *model;
 
@@ -130,6 +131,9 @@ int __init oprofile_arch_init(struct oprofile_operations *ops)
         if (!cur_cpu_spec->oprofile_cpu_type)
                 return -ENODEV;
 
+        if (firmware_has_feature(FW_FEATURE_ISERIES))
+                return -ENODEV;
+
         switch (cur_cpu_spec->oprofile_type) {
 #ifdef CONFIG_PPC64
                 case PPC_OPROFILE_RS64:
@@ -162,7 +166,7 @@ int __init oprofile_arch_init(struct oprofile_operations *ops)
         ops->stop = op_powerpc_stop;
         ops->backtrace = op_powerpc_backtrace;
 
-        printk(KERN_INFO "oprofile: using %s performance monitoring.\n",
+        printk(KERN_DEBUG "oprofile: using %s performance monitoring.\n",
                ops->cpu_type);
 
         return 0;
diff --git a/arch/powerpc/oprofile/op_model_power4.c b/arch/powerpc/oprofile/op_model_power4.c
index 4c2beab1fdc1..506f6b79f893 100644
--- a/arch/powerpc/oprofile/op_model_power4.c
+++ b/arch/powerpc/oprofile/op_model_power4.c
@@ -24,10 +24,6 @@
 static unsigned long reset_value[OP_MAX_COUNTER];
 
 static int oprofile_running;
-static int mmcra_has_sihv;
-/* Unfortunately these bits vary between CPUs */
-static unsigned long mmcra_sihv = MMCRA_SIHV;
-static unsigned long mmcra_sipr = MMCRA_SIPR;
 
 /* mmcr values are set in power4_reg_setup, used in power4_cpu_setup */
 static u32 mmcr0_val;
@@ -41,16 +37,6 @@ static void power4_reg_setup(struct op_counter_config *ctr,
         int i;
 
         /*
-         * SIHV / SIPR bits are only implemented on POWER4+ (GQ) and above.
-         * However we disable it on all POWER4 until we verify it works
-         * (I was seeing some strange behaviour last time I tried).
-         *
-         * It has been verified to work on POWER5 so we enable it there.
-         */
-        if (cpu_has_feature(CPU_FTR_MMCRA_SIHV))
-                mmcra_has_sihv = 1;
-
-        /*
          * The performance counter event settings are given in the mmcr0,
          * mmcr1 and mmcra values passed from the user in the
          * op_system_config structure (sys variable).
@@ -202,18 +188,19 @@ static unsigned long get_pc(struct pt_regs *regs)
         unsigned long mmcra;
 
         /* Cant do much about it */
-        if (!mmcra_has_sihv)
+        if (!cur_cpu_spec->oprofile_mmcra_sihv)
                 return pc;
 
         mmcra = mfspr(SPRN_MMCRA);
 
         /* Were we in the hypervisor? */
-        if (firmware_has_feature(FW_FEATURE_LPAR) && (mmcra & mmcra_sihv))
+        if (firmware_has_feature(FW_FEATURE_LPAR) &&
+            (mmcra & cur_cpu_spec->oprofile_mmcra_sihv))
                 /* function descriptor madness */
                 return *((unsigned long *)hypervisor_bucket);
 
         /* We were in userspace, nothing to do */
-        if (mmcra & mmcra_sipr)
+        if (mmcra & cur_cpu_spec->oprofile_mmcra_sipr)
                 return pc;
 
 #ifdef CONFIG_PPC_RTAS
@@ -235,15 +222,14 @@ static unsigned long get_pc(struct pt_regs *regs)
         return pc;
 }
 
-static int get_kernel(unsigned long pc)
+static int get_kernel(unsigned long pc, unsigned long mmcra)
 {
         int is_kernel;
 
-        if (!mmcra_has_sihv) {
+        if (!cur_cpu_spec->oprofile_mmcra_sihv) {
                 is_kernel = is_kernel_addr(pc);
         } else {
-                unsigned long mmcra = mfspr(SPRN_MMCRA);
-                is_kernel = ((mmcra & mmcra_sipr) == 0);
+                is_kernel = ((mmcra & cur_cpu_spec->oprofile_mmcra_sipr) == 0);
         }
 
         return is_kernel;
@@ -257,9 +243,12 @@ static void power4_handle_interrupt(struct pt_regs *regs,
         int val;
         int i;
         unsigned int mmcr0;
+        unsigned long mmcra;
+
+        mmcra = mfspr(SPRN_MMCRA);
 
         pc = get_pc(regs);
-        is_kernel = get_kernel(pc);
+        is_kernel = get_kernel(pc, mmcra);
 
         /* set the PMM bit (see comment below) */
         mtmsrd(mfmsr() | MSR_PMM);
@@ -287,6 +276,10 @@ static void power4_handle_interrupt(struct pt_regs *regs,
          */
         mmcr0 &= ~MMCR0_PMAO;
 
+        /* Clear the appropriate bits in the MMCRA */
+        mmcra &= ~cur_cpu_spec->oprofile_mmcra_clear;
+        mtspr(SPRN_MMCRA, mmcra);
+
         /*
          * now clear the freeze bit, counting will not start until we
          * rfid from this exception, because only at that point will
diff --git a/arch/powerpc/platforms/85xx/Kconfig b/arch/powerpc/platforms/85xx/Kconfig
index 06e371282f57..454fc53289ab 100644
--- a/arch/powerpc/platforms/85xx/Kconfig
+++ b/arch/powerpc/platforms/85xx/Kconfig
@@ -11,13 +11,20 @@ config MPC8540_ADS
         help
           This option enables support for the MPC 8540 ADS board
 
+config MPC85xx_CDS
+        bool "Freescale MPC85xx CDS"
+        select DEFAULT_UIMAGE
+        select PPC_I8259 if PCI
+        help
+          This option enables support for the MPC85xx CDS board
+
 endchoice
 
 config MPC8540
         bool
         select PPC_UDBG_16550
         select PPC_INDIRECT_PCI
-        default y if MPC8540_ADS
+        default y if MPC8540_ADS || MPC85xx_CDS
 
 config PPC_INDIRECT_PCI_BE
         bool
diff --git a/arch/powerpc/platforms/85xx/Makefile b/arch/powerpc/platforms/85xx/Makefile
index ffc4139cb214..7615aa59c78b 100644
--- a/arch/powerpc/platforms/85xx/Makefile
+++ b/arch/powerpc/platforms/85xx/Makefile
@@ -3,3 +3,4 @@
 #
 obj-$(CONFIG_PPC_85xx)  += misc.o pci.o
 obj-$(CONFIG_MPC8540_ADS) += mpc85xx_ads.o
+obj-$(CONFIG_MPC85xx_CDS) += mpc85xx_cds.o
diff --git a/arch/powerpc/platforms/85xx/mpc85xx_cds.c b/arch/powerpc/platforms/85xx/mpc85xx_cds.c
new file mode 100644
index 000000000000..18e6e11f7020
--- /dev/null
+++ b/arch/powerpc/platforms/85xx/mpc85xx_cds.c
@@ -0,0 +1,359 @@
+/*
+ * MPC85xx setup and early boot code plus other random bits.
+ *
+ * Maintained by Kumar Gala (see MAINTAINERS for contact information)
+ *
+ * Copyright 2005 Freescale Semiconductor Inc.
+ *
+ * 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/initrd.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/mpc85xx.h>
+#include <asm/irq.h>
+#include <mm/mmu_decl.h>
+#include <asm/prom.h>
+#include <asm/udbg.h>
+#include <asm/mpic.h>
+#include <asm/i8259.h>
+
+#include <sysdev/fsl_soc.h>
+#include "mpc85xx.h"
+
+#ifndef CONFIG_PCI
+unsigned long isa_io_base = 0;
+unsigned long isa_mem_base = 0;
+#endif
+
+static int cds_pci_slot = 2;
+static volatile u8 *cadmus;
+
+/*
+ * Internal interrupts are all Level Sensitive, and Positive Polarity
+ *
+ * Note:  Likely, this table and the following function should be
+ *        obtained and derived from the OF Device Tree.
+ */
+static u_char mpc85xx_cds_openpic_initsenses[] __initdata = {
+        MPC85XX_INTERNAL_IRQ_SENSES,
+#if defined(CONFIG_PCI)
+        (IRQ_SENSE_LEVEL | IRQ_POLARITY_POSITIVE),      /* Ext 0: PCI slot 0 */
+        (IRQ_SENSE_LEVEL | IRQ_POLARITY_NEGATIVE),      /* Ext 1: PCI slot 1 */
+        (IRQ_SENSE_LEVEL | IRQ_POLARITY_NEGATIVE),      /* Ext 2: PCI slot 2 */
+        (IRQ_SENSE_LEVEL | IRQ_POLARITY_NEGATIVE),      /* Ext 3: PCI slot 3 */
+#else
+        0x0,                            /* External  0: */
+        0x0,                            /* External  1: */
+        0x0,                            /* External  2: */
+        0x0,                            /* External  3: */
+#endif
+        (IRQ_SENSE_LEVEL | IRQ_POLARITY_NEGATIVE),      /* External 5: PHY */
+        0x0,                            /* External  6: */
+        0x0,                            /* External  7: */
+        0x0,                            /* External  8: */
+        0x0,                            /* External  9: */
+        0x0,                            /* External 10: */
+#ifdef CONFIG_PCI
+        (IRQ_SENSE_LEVEL | IRQ_POLARITY_NEGATIVE),    /* Ext 11: PCI2 slot 0 */
+#else
+        0x0,                            /* External 11: */
+#endif
+};
+
+
+#ifdef CONFIG_PCI
+/*
+ * interrupt routing
+ */
+int
+mpc85xx_map_irq(struct pci_dev *dev, unsigned char idsel, unsigned char pin)
+{
+        struct pci_controller *hose = pci_bus_to_hose(dev->bus->number);
+
+        if (!hose->index)
+        {
+                /* Handle PCI1 interrupts */
+                char pci_irq_table[][4] =
+                        /*
+                         *      PCI IDSEL/INTPIN->INTLINE
+                         *        A      B      C      D
+                         */
+
+                        /* Note IRQ assignment for slots is based on which slot the elysium is
+                         * in -- in this setup elysium is in slot #2 (this PIRQA as first
+                         * interrupt on slot */
+                {
+                        { 0, 1, 2, 3 }, /* 16 - PMC */
+                        { 0, 1, 2, 3 }, /* 17 P2P (Tsi320) */
+                        { 0, 1, 2, 3 }, /* 18 - Slot 1 */
+                        { 1, 2, 3, 0 }, /* 19 - Slot 2 */
+                        { 2, 3, 0, 1 }, /* 20 - Slot 3 */
+                        { 3, 0, 1, 2 }, /* 21 - Slot 4 */
+                };
+
+                const long min_idsel = 16, max_idsel = 21, irqs_per_slot = 4;
+                int i, j;
+
+                for (i = 0; i < 6; i++)
+                        for (j = 0; j < 4; j++)
+                                pci_irq_table[i][j] =
+                                        ((pci_irq_table[i][j] + 5 -
+                                          cds_pci_slot) & 0x3) + PIRQ0A;
+
+                return PCI_IRQ_TABLE_LOOKUP;
+        } else {
+                /* Handle PCI2 interrupts (if we have one) */
+                char pci_irq_table[][4] =
+                {
+                        /*
+                         * We only have one slot and one interrupt
+                         * going to PIRQA - PIRQD */
+                        { PIRQ1A, PIRQ1A, PIRQ1A, PIRQ1A }, /* 21 - slot 0 */
+                };
+
+                const long min_idsel = 21, max_idsel = 21, irqs_per_slot = 4;
+
+                return PCI_IRQ_TABLE_LOOKUP;
+        }
+}
+
+#define ARCADIA_HOST_BRIDGE_IDSEL       17
+#define ARCADIA_2ND_BRIDGE_IDSEL        3
+
+extern int mpc85xx_pci2_busno;
+
+int
+mpc85xx_exclude_device(u_char bus, u_char devfn)
+{
+        if (bus == 0 && PCI_SLOT(devfn) == 0)
+                return PCIBIOS_DEVICE_NOT_FOUND;
+        if (mpc85xx_pci2_busno)
+                if (bus == (mpc85xx_pci2_busno) && PCI_SLOT(devfn) == 0)
+                        return PCIBIOS_DEVICE_NOT_FOUND;
+        /* We explicitly do not go past the Tundra 320 Bridge */
+        if ((bus == 1) && (PCI_SLOT(devfn) == ARCADIA_2ND_BRIDGE_IDSEL))
+                return PCIBIOS_DEVICE_NOT_FOUND;
+        if ((bus == 0) && (PCI_SLOT(devfn) == ARCADIA_2ND_BRIDGE_IDSEL))
+                return PCIBIOS_DEVICE_NOT_FOUND;
+        else
+                return PCIBIOS_SUCCESSFUL;
+}
+
+void __init
+mpc85xx_cds_pcibios_fixup(void)
+{
+        struct pci_dev *dev;
+        u_char          c;
+
+        if ((dev = pci_get_device(PCI_VENDOR_ID_VIA,
+                                        PCI_DEVICE_ID_VIA_82C586_1, NULL))) {
+                /*
+                 * U-Boot does not set the enable bits
+                 * for the IDE device. Force them on here.
+                 */
+                pci_read_config_byte(dev, 0x40, &c);
+                c |= 0x03; /* IDE: Chip Enable Bits */
+                pci_write_config_byte(dev, 0x40, c);
+
+                /*
+                 * Since only primary interface works, force the
+                 * IDE function to standard primary IDE interrupt
+                 * w/ 8259 offset
+                 */
+                dev->irq = 14;
+                pci_write_config_byte(dev, PCI_INTERRUPT_LINE, dev->irq);
+                pci_dev_put(dev);
+        }
+
+        /*
+         * Force legacy USB interrupt routing
+         */
+        if ((dev = pci_get_device(PCI_VENDOR_ID_VIA,
+                                        PCI_DEVICE_ID_VIA_82C586_2, NULL))) {
+                dev->irq = 10;
+                pci_write_config_byte(dev, PCI_INTERRUPT_LINE, 10);
+                pci_dev_put(dev);
+        }
+
+        if ((dev = pci_get_device(PCI_VENDOR_ID_VIA,
+                                        PCI_DEVICE_ID_VIA_82C586_2, dev))) {
+                dev->irq = 11;
+                pci_write_config_byte(dev, PCI_INTERRUPT_LINE, 11);
+                pci_dev_put(dev);
+        }
+}
+#endif /* CONFIG_PCI */
+
+void __init mpc85xx_cds_pic_init(void)
+{
+        struct mpic *mpic1;
+        phys_addr_t OpenPIC_PAddr;
+
+        /* Determine the Physical Address of the OpenPIC regs */
+        OpenPIC_PAddr = get_immrbase() + MPC85xx_OPENPIC_OFFSET;
+
+        mpic1 = mpic_alloc(OpenPIC_PAddr,
+                        MPIC_PRIMARY | MPIC_WANTS_RESET | MPIC_BIG_ENDIAN,
+                        4, MPC85xx_OPENPIC_IRQ_OFFSET, 0, 250,
+                        mpc85xx_cds_openpic_initsenses,
+                        sizeof(mpc85xx_cds_openpic_initsenses), " OpenPIC  ");
+        BUG_ON(mpic1 == NULL);
+        mpic_assign_isu(mpic1, 0, OpenPIC_PAddr + 0x10200);
+        mpic_assign_isu(mpic1, 1, OpenPIC_PAddr + 0x10280);
+        mpic_assign_isu(mpic1, 2, OpenPIC_PAddr + 0x10300);
+        mpic_assign_isu(mpic1, 3, OpenPIC_PAddr + 0x10380);
+        mpic_assign_isu(mpic1, 4, OpenPIC_PAddr + 0x10400);
+        mpic_assign_isu(mpic1, 5, OpenPIC_PAddr + 0x10480);
+        mpic_assign_isu(mpic1, 6, OpenPIC_PAddr + 0x10500);
+        mpic_assign_isu(mpic1, 7, OpenPIC_PAddr + 0x10580);
+
+        /* dummy mappings to get to 48 */
+        mpic_assign_isu(mpic1, 8, OpenPIC_PAddr + 0x10600);
+        mpic_assign_isu(mpic1, 9, OpenPIC_PAddr + 0x10680);
+        mpic_assign_isu(mpic1, 10, OpenPIC_PAddr + 0x10700);
+        mpic_assign_isu(mpic1, 11, OpenPIC_PAddr + 0x10780);
+
+        /* External ints */
+        mpic_assign_isu(mpic1, 12, OpenPIC_PAddr + 0x10000);
+        mpic_assign_isu(mpic1, 13, OpenPIC_PAddr + 0x10080);
+        mpic_assign_isu(mpic1, 14, OpenPIC_PAddr + 0x10100);
+
+        mpic_init(mpic1);
+
+#ifdef CONFIG_PCI
+        mpic_setup_cascade(PIRQ0A, i8259_irq_cascade, NULL);
+
+        i8259_init(0,0);
+#endif
+}
+
+
+/*
+ * Setup the architecture
+ */
+static void __init
+mpc85xx_cds_setup_arch(void)
+{
+        struct device_node *cpu;
+#ifdef CONFIG_PCI
+        struct device_node *np;
+#endif
+
+        if (ppc_md.progress)
+                ppc_md.progress("mpc85xx_cds_setup_arch()", 0);
+
+        cpu = of_find_node_by_type(NULL, "cpu");
+        if (cpu != 0) {
+                unsigned int *fp;
+
+                fp = (int *)get_property(cpu, "clock-frequency", NULL);
+                if (fp != 0)
+                        loops_per_jiffy = *fp / HZ;
+                else
+                        loops_per_jiffy = 500000000 / HZ;
+                of_node_put(cpu);
+        }
+
+        cadmus = ioremap(CADMUS_BASE, CADMUS_SIZE);
+        cds_pci_slot = ((cadmus[CM_CSR] >> 6) & 0x3) + 1;
+
+        if (ppc_md.progress) {
+                char buf[40];
+                snprintf(buf, 40, "CDS Version = 0x%x in slot %d\n",
+                                cadmus[CM_VER], cds_pci_slot);
+                ppc_md.progress(buf, 0);
+        }
+
+#ifdef CONFIG_PCI
+        for (np = NULL; (np = of_find_node_by_type(np, "pci")) != NULL;)
+                add_bridge(np);
+
+        ppc_md.pcibios_fixup = mpc85xx_cds_pcibios_fixup;
+        ppc_md.pci_swizzle = common_swizzle;
+        ppc_md.pci_map_irq = mpc85xx_map_irq;
+        ppc_md.pci_exclude_device = mpc85xx_exclude_device;
+#endif
+
+#ifdef  CONFIG_ROOT_NFS
+        ROOT_DEV = Root_NFS;
+#else
+        ROOT_DEV = Root_HDA1;
+#endif
+}
+
+
+void
+mpc85xx_cds_show_cpuinfo(struct seq_file *m)
+{
+        uint pvid, svid, phid1;
+        uint memsize = total_memory;
+
+        pvid = mfspr(SPRN_PVR);
+        svid = mfspr(SPRN_SVR);
+
+        seq_printf(m, "Vendor\t\t: Freescale Semiconductor\n");
+        seq_printf(m, "Machine\t\t: MPC85xx CDS (0x%x)\n", cadmus[CM_VER]);
+        seq_printf(m, "PVR\t\t: 0x%x\n", pvid);
+        seq_printf(m, "SVR\t\t: 0x%x\n", svid);
+
+        /* Display cpu Pll setting */
+        phid1 = mfspr(SPRN_HID1);
+        seq_printf(m, "PLL setting\t: 0x%x\n", ((phid1 >> 24) & 0x3f));
+
+        /* Display the amount of memory */
+        seq_printf(m, "Memory\t\t: %d MB\n", memsize / (1024 * 1024));
+}
+
+
+/*
+ * Called very early, device-tree isn't unflattened
+ */
+static int __init mpc85xx_cds_probe(void)
+{
+        /* We always match for now, eventually we should look at
+         * the flat dev tree to ensure this is the board we are
+         * supposed to run on
+         */
+        return 1;
+}
+
+define_machine(mpc85xx_cds) {
+        .name           = "MPC85xx CDS",
+        .probe          = mpc85xx_cds_probe,
+        .setup_arch     = mpc85xx_cds_setup_arch,
+        .init_IRQ       = mpc85xx_cds_pic_init,
+        .show_cpuinfo   = mpc85xx_cds_show_cpuinfo,
+        .get_irq        = mpic_get_irq,
+        .restart        = mpc85xx_restart,
+        .calibrate_decr = generic_calibrate_decr,
+        .progress       = udbg_progress,
+};
diff --git a/arch/powerpc/platforms/85xx/mpc85xx_cds.h b/arch/powerpc/platforms/85xx/mpc85xx_cds.h
new file mode 100644
index 000000000000..671f54ff185a
--- /dev/null
+++ b/arch/powerpc/platforms/85xx/mpc85xx_cds.h
@@ -0,0 +1,43 @@
+/*
+ * arch/ppc/platforms/85xx/mpc85xx_cds_common.h
+ *
+ * MPC85xx CDS board definitions
+ *
+ * Maintainer: Kumar Gala <galak@kernel.crashing.org>
+ *
+ * Copyright 2004 Freescale Semiconductor, Inc
+ *
+ * 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_MPC85XX_CDS_H__
+#define __MACH_MPC85XX_CDS_H__
+
+/* CADMUS info */
+#define CADMUS_BASE (0xf8004000)
+#define CADMUS_SIZE (256)
+#define CM_VER  (0)
+#define CM_CSR  (1)
+#define CM_RST  (2)
+
+/* CDS NVRAM/RTC */
+#define CDS_RTC_ADDR    (0xf8000000)
+#define CDS_RTC_SIZE    (8 * 1024)
+
+/* PCI interrupt controller */
+#define PIRQ0A                  MPC85xx_IRQ_EXT0
+#define PIRQ0B                  MPC85xx_IRQ_EXT1
+#define PIRQ0C                  MPC85xx_IRQ_EXT2
+#define PIRQ0D                  MPC85xx_IRQ_EXT3
+#define PIRQ1A                  MPC85xx_IRQ_EXT11
+
+#define NR_8259_INTS            16
+#define CPM_IRQ_OFFSET          NR_8259_INTS
+
+#define MPC85xx_OPENPIC_IRQ_OFFSET      80
+
+#endif /* __MACH_MPC85XX_CDS_H__ */
diff --git a/arch/powerpc/platforms/86xx/Kconfig b/arch/powerpc/platforms/86xx/Kconfig
new file mode 100644
index 000000000000..3a87863d2876
--- /dev/null
+++ b/arch/powerpc/platforms/86xx/Kconfig
@@ -0,0 +1,36 @@
+menu "Platform Support"
+        depends on PPC_86xx
+
+choice
+        prompt "Machine Type"
+        default MPC8641_HPCN
+
+config MPC8641_HPCN
+        bool "Freescale MPC8641 HPCN"
+        help
+          This option enables support for the MPC8641 HPCN board.
+
+endchoice
+
+
+config MPC8641
+        bool
+        select PPC_INDIRECT_PCI
+        select PPC_UDBG_16550
+        default y if MPC8641_HPCN
+
+config MPIC
+        bool
+        default y
+
+config PPC_INDIRECT_PCI_BE
+        bool
+        depends on PPC_86xx
+        default y
+
+config PPC_STD_MMU
+        bool
+        depends on PPC_86xx
+        default y
+
+endmenu
diff --git a/arch/powerpc/platforms/86xx/Makefile b/arch/powerpc/platforms/86xx/Makefile
new file mode 100644
index 000000000000..7be796c5d5c9
--- /dev/null
+++ b/arch/powerpc/platforms/86xx/Makefile
@@ -0,0 +1,10 @@
+#
+# Makefile for the PowerPC 86xx linux kernel.
+#
+
+
+ifeq ($(CONFIG_PPC_86xx),y)
+obj-$(CONFIG_SMP)               += mpc86xx_smp.o
+endif
+obj-$(CONFIG_MPC8641_HPCN)      += mpc86xx_hpcn.o
+obj-$(CONFIG_PCI)               += pci.o mpc86xx_pcie.o
diff --git a/arch/powerpc/platforms/86xx/mpc8641_hpcn.h b/arch/powerpc/platforms/86xx/mpc8641_hpcn.h
new file mode 100644
index 000000000000..5042253758b7
--- /dev/null
+++ b/arch/powerpc/platforms/86xx/mpc8641_hpcn.h
@@ -0,0 +1,54 @@
+/*
+ * MPC8641 HPCN board definitions
+ *
+ * Copyright 2006 Freescale Semiconductor Inc.
+ *
+ * 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.
+ *
+ * Author: Xianghua Xiao <x.xiao@freescale.com>
+ */
+
+#ifndef __MPC8641_HPCN_H__
+#define __MPC8641_HPCN_H__
+
+#include <linux/config.h>
+#include <linux/init.h>
+
+/* PCI interrupt controller */
+#define PIRQA           3
+#define PIRQB           4
+#define PIRQC           5
+#define PIRQD           6
+#define PIRQ7           7
+#define PIRQE           9
+#define PIRQF           10
+#define PIRQG           11
+#define PIRQH           12
+
+/* PCI-Express memory map */
+#define MPC86XX_PCIE_LOWER_IO        0x00000000
+#define MPC86XX_PCIE_UPPER_IO        0x00ffffff
+
+#define MPC86XX_PCIE_LOWER_MEM       0x80000000
+#define MPC86XX_PCIE_UPPER_MEM       0x9fffffff
+
+#define MPC86XX_PCIE_IO_BASE         0xe2000000
+#define MPC86XX_PCIE_MEM_OFFSET      0x00000000
+
+#define MPC86XX_PCIE_IO_SIZE         0x01000000
+
+#define PCIE1_CFG_ADDR_OFFSET    (0x8000)
+#define PCIE1_CFG_DATA_OFFSET    (0x8004)
+
+#define PCIE2_CFG_ADDR_OFFSET    (0x9000)
+#define PCIE2_CFG_DATA_OFFSET    (0x9004)
+
+#define MPC86xx_PCIE_OFFSET PCIE1_CFG_ADDR_OFFSET
+#define MPC86xx_PCIE_SIZE       (0x1000)
+
+#define MPC86XX_RSTCR_OFFSET    (0xe00b0)       /* Reset Control Register */
+
+#endif  /* __MPC8641_HPCN_H__ */
diff --git a/arch/powerpc/platforms/86xx/mpc86xx.h b/arch/powerpc/platforms/86xx/mpc86xx.h
new file mode 100644
index 000000000000..e3c9e4f417d3
--- /dev/null
+++ b/arch/powerpc/platforms/86xx/mpc86xx.h
@@ -0,0 +1,28 @@
+/*
+ * Copyright 2006 Freescale Semiconductor Inc.
+ *
+ * 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 __MPC86XX_H__
+#define __MPC86XX_H__
+
+/*
+ * Declaration for the various functions exported by the
+ * mpc86xx_* files. Mostly for use by mpc86xx_setup().
+ */
+
+extern int __init add_bridge(struct device_node *dev);
+
+extern void __init setup_indirect_pcie(struct pci_controller *hose,
+                                       u32 cfg_addr, u32 cfg_data);
+extern void __init setup_indirect_pcie_nomap(struct pci_controller *hose,
+                                             void __iomem *cfg_addr,
+                                             void __iomem *cfg_data);
+
+extern void __init mpc86xx_smp_init(void);
+
+#endif  /* __MPC86XX_H__ */
diff --git a/arch/powerpc/platforms/86xx/mpc86xx_hpcn.c b/arch/powerpc/platforms/86xx/mpc86xx_hpcn.c
new file mode 100644
index 000000000000..483c21df181e
--- /dev/null
+++ b/arch/powerpc/platforms/86xx/mpc86xx_hpcn.c
@@ -0,0 +1,326 @@
+/*
+ * MPC86xx HPCN board specific routines
+ *
+ * Recode: ZHANG WEI <wei.zhang@freescale.com>
+ * Initial author: Xianghua Xiao <x.xiao@freescale.com>
+ *
+ * Copyright 2006 Freescale Semiconductor Inc.
+ *
+ * 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/pci.h>
+#include <linux/kdev_t.h>
+#include <linux/delay.h>
+#include <linux/seq_file.h>
+#include <linux/root_dev.h>
+
+#include <asm/system.h>
+#include <asm/time.h>
+#include <asm/machdep.h>
+#include <asm/pci-bridge.h>
+#include <asm/mpc86xx.h>
+#include <asm/prom.h>
+#include <mm/mmu_decl.h>
+#include <asm/udbg.h>
+#include <asm/i8259.h>
+
+#include <asm/mpic.h>
+
+#include <sysdev/fsl_soc.h>
+
+#include "mpc86xx.h"
+
+#ifndef CONFIG_PCI
+unsigned long isa_io_base = 0;
+unsigned long isa_mem_base = 0;
+unsigned long pci_dram_offset = 0;
+#endif
+
+
+/*
+ * Internal interrupts are all Level Sensitive, and Positive Polarity
+ */
+
+static u_char mpc86xx_hpcn_openpic_initsenses[] __initdata = {
+        (IRQ_SENSE_LEVEL | IRQ_POLARITY_POSITIVE),      /* Internal  0: Reserved */
+        (IRQ_SENSE_LEVEL | IRQ_POLARITY_POSITIVE),      /* Internal  1: MCM */
+        (IRQ_SENSE_LEVEL | IRQ_POLARITY_POSITIVE),      /* Internal  2: DDR DRAM */
+        (IRQ_SENSE_LEVEL | IRQ_POLARITY_POSITIVE),      /* Internal  3: LBIU */
+        (IRQ_SENSE_LEVEL | IRQ_POLARITY_POSITIVE),      /* Internal  4: DMA 0 */
+        (IRQ_SENSE_LEVEL | IRQ_POLARITY_POSITIVE),      /* Internal  5: DMA 1 */
+        (IRQ_SENSE_LEVEL | IRQ_POLARITY_POSITIVE),      /* Internal  6: DMA 2 */
+        (IRQ_SENSE_LEVEL | IRQ_POLARITY_POSITIVE),      /* Internal  7: DMA 3 */
+        (IRQ_SENSE_LEVEL | IRQ_POLARITY_POSITIVE),      /* Internal  8: PCIE1 */
+        (IRQ_SENSE_LEVEL | IRQ_POLARITY_POSITIVE),      /* Internal  9: PCIE2 */
+        (IRQ_SENSE_LEVEL | IRQ_POLARITY_POSITIVE),      /* Internal 10: Reserved */
+        (IRQ_SENSE_LEVEL | IRQ_POLARITY_POSITIVE),      /* Internal 11: Reserved */
+        (IRQ_SENSE_LEVEL | IRQ_POLARITY_POSITIVE),      /* Internal 12: DUART2 */
+        (IRQ_SENSE_LEVEL | IRQ_POLARITY_POSITIVE),      /* Internal 13: TSEC 1 Transmit */
+        (IRQ_SENSE_LEVEL | IRQ_POLARITY_POSITIVE),      /* Internal 14: TSEC 1 Receive */
+        (IRQ_SENSE_LEVEL | IRQ_POLARITY_POSITIVE),      /* Internal 15: TSEC 3 transmit */
+        (IRQ_SENSE_LEVEL | IRQ_POLARITY_POSITIVE),      /* Internal 16: TSEC 3 receive */
+        (IRQ_SENSE_LEVEL | IRQ_POLARITY_POSITIVE),      /* Internal 17: TSEC 3 error */
+        (IRQ_SENSE_LEVEL | IRQ_POLARITY_POSITIVE),      /* Internal 18: TSEC 1 Receive/Transmit Error */
+        (IRQ_SENSE_LEVEL | IRQ_POLARITY_POSITIVE),      /* Internal 19: TSEC 2 Transmit */
+        (IRQ_SENSE_LEVEL | IRQ_POLARITY_POSITIVE),      /* Internal 20: TSEC 2 Receive */
+        (IRQ_SENSE_LEVEL | IRQ_POLARITY_POSITIVE),      /* Internal 21: TSEC 4 transmit */
+        (IRQ_SENSE_LEVEL | IRQ_POLARITY_POSITIVE),      /* Internal 22: TSEC 4 receive */
+        (IRQ_SENSE_LEVEL | IRQ_POLARITY_POSITIVE),      /* Internal 23: TSEC 4 error */
+        (IRQ_SENSE_LEVEL | IRQ_POLARITY_POSITIVE),      /* Internal 24: TSEC 2 Receive/Transmit Error */
+        (IRQ_SENSE_LEVEL | IRQ_POLARITY_POSITIVE),      /* Internal 25: Unused */
+        (IRQ_SENSE_LEVEL | IRQ_POLARITY_POSITIVE),      /* Internal 26: DUART1 */
+        (IRQ_SENSE_LEVEL | IRQ_POLARITY_POSITIVE),      /* Internal 27: I2C */
+        (IRQ_SENSE_LEVEL | IRQ_POLARITY_POSITIVE),      /* Internal 28: Performance Monitor */
+        (IRQ_SENSE_LEVEL | IRQ_POLARITY_POSITIVE),      /* Internal 29: Unused */
+        (IRQ_SENSE_LEVEL | IRQ_POLARITY_POSITIVE),      /* Internal 30: Unused */
+        (IRQ_SENSE_LEVEL | IRQ_POLARITY_POSITIVE),      /* Internal 31: Unused */
+        (IRQ_SENSE_LEVEL | IRQ_POLARITY_POSITIVE),      /* Internal 32: SRIO error/write-port unit */
+        (IRQ_SENSE_LEVEL | IRQ_POLARITY_POSITIVE),      /* Internal 33: SRIO outbound doorbell */
+        (IRQ_SENSE_LEVEL | IRQ_POLARITY_POSITIVE),      /* Internal 34: SRIO inbound doorbell */
+        (IRQ_SENSE_LEVEL | IRQ_POLARITY_POSITIVE),      /* Internal 35: Unused */
+        (IRQ_SENSE_LEVEL | IRQ_POLARITY_POSITIVE),      /* Internal 36: Unused */
+        (IRQ_SENSE_LEVEL | IRQ_POLARITY_POSITIVE),      /* Internal 37: SRIO outbound message unit 1 */
+        (IRQ_SENSE_LEVEL | IRQ_POLARITY_POSITIVE),      /* Internal 38: SRIO inbound message unit 1 */
+        (IRQ_SENSE_LEVEL | IRQ_POLARITY_POSITIVE),      /* Internal 39: SRIO outbound message unit 2 */
+        (IRQ_SENSE_LEVEL | IRQ_POLARITY_POSITIVE),      /* Internal 40: SRIO inbound message unit 2 */
+        (IRQ_SENSE_LEVEL | IRQ_POLARITY_POSITIVE),      /* Internal 41: Unused */
+        (IRQ_SENSE_LEVEL | IRQ_POLARITY_POSITIVE),      /* Internal 42: Unused */
+        (IRQ_SENSE_LEVEL | IRQ_POLARITY_POSITIVE),      /* Internal 43: Unused */
+        (IRQ_SENSE_LEVEL | IRQ_POLARITY_POSITIVE),      /* Internal 44: Unused */
+        (IRQ_SENSE_LEVEL | IRQ_POLARITY_POSITIVE),      /* Internal 45: Unused */
+        (IRQ_SENSE_LEVEL | IRQ_POLARITY_POSITIVE),      /* Internal 46: Unused */
+        (IRQ_SENSE_LEVEL | IRQ_POLARITY_POSITIVE),      /* Internal 47: Unused */
+        0x0,                                            /* External  0: */
+        0x0,                                            /* External  1: */
+        0x0,                                            /* External  2: */
+        0x0,                                            /* External  3: */
+        0x0,                                            /* External  4: */
+        0x0,                                            /* External  5: */
+        0x0,                                            /* External  6: */
+        0x0,                                            /* External  7: */
+        (IRQ_SENSE_LEVEL | IRQ_POLARITY_NEGATIVE),      /* External  8: Pixis FPGA */
+        (IRQ_SENSE_LEVEL | IRQ_POLARITY_POSITIVE),      /* External  9: ULI 8259 INTR Cascade */
+        (IRQ_SENSE_LEVEL | IRQ_POLARITY_NEGATIVE),      /* External 10: Quad ETH PHY */
+        0x0,                                            /* External 11: */
+        0x0,
+        0x0,
+        0x0,
+        0x0,
+};
+
+
+void __init
+mpc86xx_hpcn_init_irq(void)
+{
+        struct mpic *mpic1;
+        phys_addr_t openpic_paddr;
+
+        /* Determine the Physical Address of the OpenPIC regs */
+        openpic_paddr = get_immrbase() + MPC86xx_OPENPIC_OFFSET;
+
+        /* Alloc mpic structure and per isu has 16 INT entries. */
+        mpic1 = mpic_alloc(openpic_paddr,
+                        MPIC_PRIMARY | MPIC_WANTS_RESET | MPIC_BIG_ENDIAN,
+                        16, MPC86xx_OPENPIC_IRQ_OFFSET, 0, 250,
+                        mpc86xx_hpcn_openpic_initsenses,
+                        sizeof(mpc86xx_hpcn_openpic_initsenses),
+                        " MPIC     ");
+        BUG_ON(mpic1 == NULL);
+
+        /* 48 Internal Interrupts */
+        mpic_assign_isu(mpic1, 0, openpic_paddr + 0x10200);
+        mpic_assign_isu(mpic1, 1, openpic_paddr + 0x10400);
+        mpic_assign_isu(mpic1, 2, openpic_paddr + 0x10600);
+
+        /* 16 External interrupts */
+        mpic_assign_isu(mpic1, 3, openpic_paddr + 0x10000);
+
+        mpic_init(mpic1);
+
+#ifdef CONFIG_PCI
+        mpic_setup_cascade(MPC86xx_IRQ_EXT9, i8259_irq_cascade, NULL);
+        i8259_init(0, I8259_OFFSET);
+#endif
+}
+
+
+
+#ifdef CONFIG_PCI
+/*
+ * interrupt routing
+ */
+
+int
+mpc86xx_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 17 -- PCI Slot 1 */
+                {PIRQB, PIRQC, PIRQD, PIRQA},   /* IDSEL 18 -- PCI Slot 2 */
+                {0, 0, 0, 0},                   /* IDSEL 19 */
+                {0, 0, 0, 0},                   /* IDSEL 20 */
+                {0, 0, 0, 0},                   /* IDSEL 21 */
+                {0, 0, 0, 0},                   /* IDSEL 22 */
+                {0, 0, 0, 0},                   /* IDSEL 23 */
+                {0, 0, 0, 0},                   /* IDSEL 24 */
+                {0, 0, 0, 0},                   /* IDSEL 25 */
+                {PIRQD, PIRQA, PIRQB, PIRQC},   /* IDSEL 26 -- PCI Bridge*/
+                {PIRQC, 0, 0, 0},               /* IDSEL 27 -- LAN */
+                {PIRQE, PIRQF, PIRQH, PIRQ7},   /* IDSEL 28 -- USB 1.1 */
+                {PIRQE, PIRQF, PIRQG, 0},       /* IDSEL 29 -- Audio & Modem */
+                {PIRQH, 0, 0, 0},               /* IDSEL 30 -- LPC & PMU*/
+                {PIRQD, 0, 0, 0},               /* IDSEL 31 -- ATA */
+        };
+
+        const long min_idsel = 17, max_idsel = 31, irqs_per_slot = 4;
+        return PCI_IRQ_TABLE_LOOKUP + I8259_OFFSET;
+}
+
+
+int
+mpc86xx_exclude_device(u_char bus, u_char devfn)
+{
+#if !defined(CONFIG_PCI)
+        if (bus == 0 && PCI_SLOT(devfn) == 0)
+                return PCIBIOS_DEVICE_NOT_FOUND;
+#endif
+
+        return PCIBIOS_SUCCESSFUL;
+}
+#endif /* CONFIG_PCI */
+
+
+static void __init
+mpc86xx_hpcn_setup_arch(void)
+{
+        struct device_node *np;
+
+        if (ppc_md.progress)
+                ppc_md.progress("mpc86xx_hpcn_setup_arch()", 0);
+
+        np = of_find_node_by_type(NULL, "cpu");
+        if (np != 0) {
+                unsigned int *fp;
+
+                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 = mpc86xx_map_irq;
+        ppc_md.pci_exclude_device = mpc86xx_exclude_device;
+#endif
+
+        printk("MPC86xx HPCN board from Freescale Semiconductor\n");
+
+#ifdef  CONFIG_ROOT_NFS
+        ROOT_DEV = Root_NFS;
+#else
+        ROOT_DEV = Root_HDA1;
+#endif
+
+#ifdef CONFIG_SMP
+        mpc86xx_smp_init();
+#endif
+}
+
+
+void
+mpc86xx_hpcn_show_cpuinfo(struct seq_file *m)
+{
+        struct device_node *root;
+        uint memsize = total_memory;
+        const char *model = "";
+        uint svid = mfspr(SPRN_SVR);
+
+        seq_printf(m, "Vendor\t\t: Freescale Semiconductor\n");
+
+        root = of_find_node_by_path("/");
+        if (root)
+                model = get_property(root, "model", NULL);
+        seq_printf(m, "Machine\t\t: %s\n", model);
+        of_node_put(root);
+
+        seq_printf(m, "SVR\t\t: 0x%x\n", svid);
+        seq_printf(m, "Memory\t\t: %d MB\n", memsize / (1024 * 1024));
+}
+
+
+/*
+ * Called very early, device-tree isn't unflattened
+ */
+static int __init mpc86xx_hpcn_probe(void)
+{
+        unsigned long root = of_get_flat_dt_root();
+
+        if (of_flat_dt_is_compatible(root, "mpc86xx"))
+                return 1;       /* Looks good */
+
+        return 0;
+}
+
+
+void
+mpc86xx_restart(char *cmd)
+{
+        void __iomem *rstcr;
+
+        rstcr = ioremap(get_immrbase() + MPC86XX_RSTCR_OFFSET, 0x100);
+
+        local_irq_disable();
+
+        /* Assert reset request to Reset Control Register */
+        out_be32(rstcr, 0x2);
+
+        /* not reached */
+}
+
+
+long __init
+mpc86xx_time_init(void)
+{
+        unsigned int temp;
+
+        /* Set the time base to zero */
+        mtspr(SPRN_TBWL, 0);
+        mtspr(SPRN_TBWU, 0);
+
+        temp = mfspr(SPRN_HID0);
+        temp |= HID0_TBEN;
+        mtspr(SPRN_HID0, temp);
+        asm volatile("isync");
+
+        return 0;
+}
+
+
+define_machine(mpc86xx_hpcn) {
+        .name                   = "MPC86xx HPCN",
+        .probe                  = mpc86xx_hpcn_probe,
+        .setup_arch             = mpc86xx_hpcn_setup_arch,
+        .init_IRQ               = mpc86xx_hpcn_init_irq,
+        .show_cpuinfo           = mpc86xx_hpcn_show_cpuinfo,
+        .get_irq                = mpic_get_irq,
+        .restart                = mpc86xx_restart,
+        .time_init              = mpc86xx_time_init,
+        .calibrate_decr         = generic_calibrate_decr,
+        .progress               = udbg_progress,
+};
diff --git a/arch/powerpc/platforms/86xx/mpc86xx_pcie.c b/arch/powerpc/platforms/86xx/mpc86xx_pcie.c
new file mode 100644
index 000000000000..a2f4f730213e
--- /dev/null
+++ b/arch/powerpc/platforms/86xx/mpc86xx_pcie.c
@@ -0,0 +1,173 @@
+/*
+ * Support for indirect PCI bridges.
+ *
+ * Copyright (C) 1998 Gabriel Paubert.
+ *
+ * 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.
+ *
+ * "Temporary" MPC8548 Errata file -
+ * The standard indirect_pci code should work with future silicon versions.
+ */
+
+#include <linux/kernel.h>
+#include <linux/pci.h>
+#include <linux/delay.h>
+#include <linux/string.h>
+#include <linux/init.h>
+#include <linux/bootmem.h>
+
+#include <asm/io.h>
+#include <asm/prom.h>
+#include <asm/pci-bridge.h>
+#include <asm/machdep.h>
+
+#include "mpc86xx.h"
+
+#define PCI_CFG_OUT out_be32
+
+/* ERRATA PCI-Ex 14 PCIE Controller timeout */
+#define PCIE_FIX                out_be32(hose->cfg_addr+0x4, 0x0400ffff)
+
+
+static int
+indirect_read_config_pcie(struct pci_bus *bus, unsigned int devfn, int offset,
+                     int len, u32 *val)
+{
+        struct pci_controller *hose = bus->sysdata;
+        volatile void __iomem *cfg_data;
+        u32 temp;
+
+        if (ppc_md.pci_exclude_device)
+                if (ppc_md.pci_exclude_device(bus->number, devfn))
+                        return PCIBIOS_DEVICE_NOT_FOUND;
+
+        /* Possible artifact of CDCpp50937 needs further investigation */
+        if (devfn != 0x0 && bus->number == 0xff)
+                return PCIBIOS_DEVICE_NOT_FOUND;
+
+        PCIE_FIX;
+        if (bus->number == 0xff) {
+                PCI_CFG_OUT(hose->cfg_addr,
+                            (0x80000000 | ((offset & 0xf00) << 16) |
+                             ((bus->number - hose->bus_offset) << 16)
+                             | (devfn << 8) | ((offset & 0xfc) )));
+        } else {
+                PCI_CFG_OUT(hose->cfg_addr,
+                            (0x80000001 | ((offset & 0xf00) << 16) |
+                             ((bus->number - hose->bus_offset) << 16)
+                             | (devfn << 8) | ((offset & 0xfc) )));
+        }
+
+        /*
+         * Note: the caller has already checked that offset is
+         * suitably aligned and that len is 1, 2 or 4.
+         */
+        /* ERRATA PCI-Ex 12 - Configuration Address/Data Alignment */
+        cfg_data = hose->cfg_data;
+        PCIE_FIX;
+        temp = in_le32(cfg_data);
+        switch (len) {
+        case 1:
+                *val = (temp >> (((offset & 3))*8)) & 0xff;
+                break;
+        case 2:
+                *val = (temp >> (((offset & 3))*8)) & 0xffff;
+                break;
+        default:
+                *val = temp;
+                break;
+        }
+        return PCIBIOS_SUCCESSFUL;
+}
+
+static int
+indirect_write_config_pcie(struct pci_bus *bus, unsigned int devfn, int offset,
+                      int len, u32 val)
+{
+        struct pci_controller *hose = bus->sysdata;
+        volatile void __iomem *cfg_data;
+        u32 temp;
+
+        if (ppc_md.pci_exclude_device)
+                if (ppc_md.pci_exclude_device(bus->number, devfn))
+                        return PCIBIOS_DEVICE_NOT_FOUND;
+
+        /* Possible artifact of CDCpp50937 needs further investigation */
+        if (devfn != 0x0 && bus->number == 0xff)
+                return PCIBIOS_DEVICE_NOT_FOUND;
+
+        PCIE_FIX;
+        if (bus->number == 0xff) {
+                PCI_CFG_OUT(hose->cfg_addr,
+                            (0x80000000 | ((offset & 0xf00) << 16) |
+                             ((bus->number - hose->bus_offset) << 16)
+                             | (devfn << 8) | ((offset & 0xfc) )));
+        } else {
+                PCI_CFG_OUT(hose->cfg_addr,
+                            (0x80000001 | ((offset & 0xf00) << 16) |
+                             ((bus->number - hose->bus_offset) << 16)
+                             | (devfn << 8) | ((offset & 0xfc) )));
+        }
+
+        /*
+         * Note: the caller has already checked that offset is
+         * suitably aligned and that len is 1, 2 or 4.
+         */
+        /* ERRATA PCI-Ex 12 - Configuration Address/Data Alignment */
+        cfg_data = hose->cfg_data;
+        switch (len) {
+        case 1:
+                PCIE_FIX;
+                temp = in_le32(cfg_data);
+                temp = (temp & ~(0xff << ((offset & 3) * 8))) |
+                        (val << ((offset & 3) * 8));
+                PCIE_FIX;
+                out_le32(cfg_data, temp);
+                break;
+        case 2:
+                PCIE_FIX;
+                temp = in_le32(cfg_data);
+                temp = (temp & ~(0xffff << ((offset & 3) * 8)));
+                temp |= (val << ((offset & 3) * 8)) ;
+                PCIE_FIX;
+                out_le32(cfg_data, temp);
+                break;
+        default:
+                PCIE_FIX;
+                out_le32(cfg_data, val);
+                break;
+        }
+        PCIE_FIX;
+        return PCIBIOS_SUCCESSFUL;
+}
+
+static struct pci_ops indirect_pcie_ops = {
+        indirect_read_config_pcie,
+        indirect_write_config_pcie
+};
+
+void __init
+setup_indirect_pcie_nomap(struct pci_controller* hose, void __iomem * cfg_addr,
+        void __iomem * cfg_data)
+{
+        hose->cfg_addr = cfg_addr;
+        hose->cfg_data = cfg_data;
+        hose->ops = &indirect_pcie_ops;
+}
+
+void __init
+setup_indirect_pcie(struct pci_controller* hose, u32 cfg_addr, u32 cfg_data)
+{
+        unsigned long base = cfg_addr & PAGE_MASK;
+        void __iomem *mbase, *addr, *data;
+
+        mbase = ioremap(base, PAGE_SIZE);
+        addr = mbase + (cfg_addr & ~PAGE_MASK);
+        if ((cfg_data & PAGE_MASK) != base)
+                mbase = ioremap(cfg_data & PAGE_MASK, PAGE_SIZE);
+        data = mbase + (cfg_data & ~PAGE_MASK);
+        setup_indirect_pcie_nomap(hose, addr, data);
+}
diff --git a/arch/powerpc/platforms/86xx/mpc86xx_smp.c b/arch/powerpc/platforms/86xx/mpc86xx_smp.c
new file mode 100644
index 000000000000..944ec4b71416
--- /dev/null
+++ b/arch/powerpc/platforms/86xx/mpc86xx_smp.c
@@ -0,0 +1,117 @@
+/*
+ * Author: Xianghua Xiao <x.xiao@freescale.com>
+ *         Zhang Wei <wei.zhang@freescale.com>
+ *
+ * Copyright 2006 Freescale Semiconductor Inc.
+ *
+ * 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/delay.h>
+
+#include <asm/pgtable.h>
+#include <asm/page.h>
+#include <asm/pci-bridge.h>
+#include <asm-powerpc/mpic.h>
+#include <asm/mpc86xx.h>
+#include <asm/cacheflush.h>
+
+#include <sysdev/fsl_soc.h>
+
+#include "mpc86xx.h"
+
+extern void __secondary_start_mpc86xx(void);
+extern unsigned long __secondary_hold_acknowledge;
+
+
+static void __init
+smp_86xx_release_core(int nr)
+{
+        void *mcm_vaddr;
+        unsigned long vaddr, pcr;
+
+        if (nr < 0 || nr >= NR_CPUS)
+                return;
+
+        /*
+         * Startup Core #nr.
+         */
+        mcm_vaddr = ioremap(get_immrbase() + MPC86xx_MCM_OFFSET,
+                            MPC86xx_MCM_SIZE);
+        vaddr = (unsigned long)mcm_vaddr +  MCM_PORT_CONFIG_OFFSET;
+        pcr = in_be32((volatile unsigned *)vaddr);
+        pcr |= 1 << (nr + 24);
+        out_be32((volatile unsigned *)vaddr, pcr);
+}
+
+
+static void __init
+smp_86xx_kick_cpu(int nr)
+{
+        unsigned int save_vector;
+        unsigned long target, flags;
+        int n = 0;
+        volatile unsigned int *vector
+                 = (volatile unsigned int *)(KERNELBASE + 0x100);
+
+        if (nr < 0 || nr >= NR_CPUS)
+                return;
+
+        pr_debug("smp_86xx_kick_cpu: kick CPU #%d\n", nr);
+
+        local_irq_save(flags);
+        local_irq_disable();
+
+        /* Save reset vector */
+        save_vector = *vector;
+
+        /* Setup fake reset vector to call __secondary_start_mpc86xx. */
+        target = (unsigned long) __secondary_start_mpc86xx;
+        create_branch((unsigned long)vector, target, BRANCH_SET_LINK);
+
+        /* Kick that CPU */
+        smp_86xx_release_core(nr);
+
+        /* Wait a bit for the CPU to take the exception. */
+        while ((__secondary_hold_acknowledge != nr) && (n++, n < 1000))
+                mdelay(1);
+
+        /* Restore the exception vector */
+        *vector = save_vector;
+        flush_icache_range((unsigned long) vector, (unsigned long) vector + 4);
+
+        local_irq_restore(flags);
+
+        pr_debug("wait CPU #%d for %d msecs.\n", nr, n);
+}
+
+
+static void __init
+smp_86xx_setup_cpu(int cpu_nr)
+{
+        mpic_setup_this_cpu();
+}
+
+
+struct smp_ops_t smp_86xx_ops = {
+        .message_pass = smp_mpic_message_pass,
+        .probe = smp_mpic_probe,
+        .kick_cpu = smp_86xx_kick_cpu,
+        .setup_cpu = smp_86xx_setup_cpu,
+        .take_timebase = smp_generic_take_timebase,
+        .give_timebase = smp_generic_give_timebase,
+};
+
+
+void __init
+mpc86xx_smp_init(void)
+{
+        smp_ops = &smp_86xx_ops;
+}
diff --git a/arch/powerpc/platforms/86xx/pci.c b/arch/powerpc/platforms/86xx/pci.c
new file mode 100644
index 000000000000..5180df7c75bc
--- /dev/null
+++ b/arch/powerpc/platforms/86xx/pci.c
@@ -0,0 +1,325 @@
+/*
+ * MPC86XX pci setup code
+ *
+ * Recode: ZHANG WEI <wei.zhang@freescale.com>
+ * Initial author: Xianghua Xiao <x.xiao@freescale.com>
+ *
+ * Copyright 2006 Freescale Semiconductor Inc.
+ *
+ * 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/types.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/pci.h>
+#include <linux/serial.h>
+
+#include <asm/system.h>
+#include <asm/atomic.h>
+#include <asm/io.h>
+#include <asm/prom.h>
+#include <asm/immap_86xx.h>
+#include <asm/pci-bridge.h>
+#include <sysdev/fsl_soc.h>
+
+#include "mpc86xx.h"
+
+#undef DEBUG
+
+#ifdef DEBUG
+#define DBG(fmt, args...) printk(KERN_ERR "%s: " fmt, __FUNCTION__, ## args)
+#else
+#define DBG(fmt, args...)
+#endif
+
+struct pcie_outbound_window_regs {
+        uint    pexotar;               /* 0x.0 - PCI Express outbound translation address register */
+        uint    pexotear;              /* 0x.4 - PCI Express outbound translation extended address register */
+        uint    pexowbar;              /* 0x.8 - PCI Express outbound window base address register */
+        char    res1[4];
+        uint    pexowar;               /* 0x.10 - PCI Express outbound window attributes register */
+        char    res2[12];
+};
+
+struct pcie_inbound_window_regs {
+        uint    pexitar;               /* 0x.0 - PCI Express inbound translation address register */
+        char    res1[4];
+        uint    pexiwbar;              /* 0x.8 - PCI Express inbound window base address register */
+        uint    pexiwbear;             /* 0x.c - PCI Express inbound window base extended address register */
+        uint    pexiwar;               /* 0x.10 - PCI Express inbound window attributes register */
+        char    res2[12];
+};
+
+static void __init setup_pcie_atmu(struct pci_controller *hose, struct resource *rsrc)
+{
+        volatile struct ccsr_pex *pcie;
+        volatile struct pcie_outbound_window_regs *pcieow;
+        volatile struct pcie_inbound_window_regs *pcieiw;
+        int i = 0;
+
+        DBG("PCIE memory map start 0x%x, size 0x%x\n", rsrc->start,
+                        rsrc->end - rsrc->start + 1);
+        pcie = ioremap(rsrc->start, rsrc->end - rsrc->start + 1);
+
+        /* Disable all windows (except pexowar0 since its ignored) */
+        pcie->pexowar1 = 0;
+        pcie->pexowar2 = 0;
+        pcie->pexowar3 = 0;
+        pcie->pexowar4 = 0;
+        pcie->pexiwar1 = 0;
+        pcie->pexiwar2 = 0;
+        pcie->pexiwar3 = 0;
+
+        pcieow = (struct pcie_outbound_window_regs *)&pcie->pexotar1;
+        pcieiw = (struct pcie_inbound_window_regs *)&pcie->pexitar1;
+
+        /* Setup outbound MEM window */
+        for(i = 0; i < 3; i++)
+                if (hose->mem_resources[i].flags & IORESOURCE_MEM){
+                        DBG("PCIE MEM resource start 0x%08x, size 0x%08x.\n",
+                                hose->mem_resources[i].start,
+                                hose->mem_resources[i].end
+                                  - hose->mem_resources[i].start + 1);
+                        pcieow->pexotar = (hose->mem_resources[i].start) >> 12
+                                & 0x000fffff;
+                        pcieow->pexotear = 0;
+                        pcieow->pexowbar = (hose->mem_resources[i].start) >> 12
+                                & 0x000fffff;
+                        /* Enable, Mem R/W */
+                        pcieow->pexowar = 0x80044000 |
+                                (__ilog2(hose->mem_resources[i].end
+                                         - hose->mem_resources[i].start + 1)
+                                 - 1);
+                        pcieow++;
+                }
+
+        /* Setup outbound IO window */
+        if (hose->io_resource.flags & IORESOURCE_IO){
+                DBG("PCIE IO resource start 0x%08x, size 0x%08x, phy base 0x%08x.\n",
+                        hose->io_resource.start,
+                        hose->io_resource.end - hose->io_resource.start + 1,
+                        hose->io_base_phys);
+                pcieow->pexotar = (hose->io_resource.start) >> 12 & 0x000fffff;
+                pcieow->pexotear = 0;
+                pcieow->pexowbar = (hose->io_base_phys) >> 12 & 0x000fffff;
+                /* Enable, IO R/W */
+                pcieow->pexowar = 0x80088000 | (__ilog2(hose->io_resource.end
+                                        - hose->io_resource.start + 1) - 1);
+        }
+
+        /* Setup 2G inbound Memory Window @ 0 */
+        pcieiw->pexitar = 0x00000000;
+        pcieiw->pexiwbar = 0x00000000;
+        /* Enable, Prefetch, Local Mem, Snoop R/W, 2G */
+        pcieiw->pexiwar = 0xa0f5501e;
+}
+
+static void __init
+mpc86xx_setup_pcie(struct pci_controller *hose, u32 pcie_offset, u32 pcie_size)
+{
+        volatile struct ccsr_pex *pcie;
+        u16 cmd;
+        unsigned int temps;
+
+        DBG("PCIE host controller register offset 0x%08x, size 0x%08x.\n",
+                        pcie_offset, pcie_size);
+
+        pcie = ioremap(pcie_offset, pcie_size);
+
+        early_read_config_word(hose, 0, 0, PCI_COMMAND, &cmd);
+        cmd |= PCI_COMMAND_SERR | PCI_COMMAND_MASTER | PCI_COMMAND_MEMORY
+            | PCI_COMMAND_IO;
+        early_write_config_word(hose, 0, 0, PCI_COMMAND, cmd);
+
+        early_write_config_byte(hose, 0, 0, PCI_LATENCY_TIMER, 0x80);
+
+        /* PCIE Bus, Fix the MPC8641D host bridge's location to bus 0xFF. */
+        early_read_config_dword(hose, 0, 0, PCI_PRIMARY_BUS, &temps);
+        temps = (temps & 0xff000000) | (0xff) | (0x0 << 8) | (0xfe << 16);
+        early_write_config_dword(hose, 0, 0, PCI_PRIMARY_BUS, temps);
+}
+
+int __init add_bridge(struct device_node *dev)
+{
+        int len;
+        struct pci_controller *hose;
+        struct resource rsrc;
+        int *bus_range;
+        int has_address = 0;
+        int primary = 0;
+
+        DBG("Adding PCIE 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;
+
+        /* last_busno = 0xfe cause by MPC8641 PCIE bug */
+        hose->first_busno = bus_range ? bus_range[0] : 0x0;
+        hose->last_busno = bus_range ? bus_range[1] : 0xfe;
+
+        setup_indirect_pcie(hose, rsrc.start, rsrc.start + 0x4);
+
+        /* Setup the PCIE host controller. */
+        mpc86xx_setup_pcie(hose, rsrc.start, rsrc.end - rsrc.start + 1);
+
+        if ((rsrc.start & 0xfffff) == 0x8000)
+                primary = 1;
+
+        printk(KERN_INFO "Found MPC86xx PCIE 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);
+
+        /* Setup PEX window registers */
+        setup_pcie_atmu(hose, &rsrc);
+
+        return 0;
+}
+
+static void __devinit quirk_ali1575(struct pci_dev *dev)
+{
+        unsigned short temp;
+
+        /*
+         * ALI1575 interrupts route table setup:
+         *
+         * IRQ pin   IRQ#
+         * PIRQA ---- 3
+         * PIRQB ---- 4
+         * PIRQC ---- 5
+         * PIRQD ---- 6
+         * PIRQE ---- 9
+         * PIRQF ---- 10
+         * PIRQG ---- 11
+         * PIRQH ---- 12
+         *
+         * interrupts for PCI slot0 -- PIRQA / PIRQB / PIRQC / PIRQD
+         *                PCI slot1 -- PIRQB / PIRQC / PIRQD / PIRQA
+         */
+        pci_write_config_dword(dev, 0x48, 0xb9317542);
+
+        /* USB 1.1 OHCI controller 1, interrupt: PIRQE */
+        pci_write_config_byte(dev, 0x86, 0x0c);
+
+        /* USB 1.1 OHCI controller 2, interrupt: PIRQF */
+        pci_write_config_byte(dev, 0x87, 0x0d);
+
+        /* USB 1.1 OHCI controller 3, interrupt: PIRQH */
+        pci_write_config_byte(dev, 0x88, 0x0f);
+
+        /* USB 2.0 controller, interrupt: PIRQ7 */
+        pci_write_config_byte(dev, 0x74, 0x06);
+
+        /* Audio controller, interrupt: PIRQE */
+        pci_write_config_byte(dev, 0x8a, 0x0c);
+
+        /* Modem controller, interrupt: PIRQF */
+        pci_write_config_byte(dev, 0x8b, 0x0d);
+
+        /* HD audio controller, interrupt: PIRQG */
+        pci_write_config_byte(dev, 0x8c, 0x0e);
+
+        /* Serial ATA interrupt: PIRQD */
+        pci_write_config_byte(dev, 0x8d, 0x0b);
+
+        /* SMB interrupt: PIRQH */
+        pci_write_config_byte(dev, 0x8e, 0x0f);
+
+        /* PMU ACPI SCI interrupt: PIRQH */
+        pci_write_config_byte(dev, 0x8f, 0x0f);
+
+        /* Primary PATA IDE IRQ: 14
+         * Secondary PATA IDE IRQ: 15
+         */
+        pci_write_config_byte(dev, 0x44, 0x3d);
+        pci_write_config_byte(dev, 0x75, 0x0f);
+
+        /* Set IRQ14 and IRQ15 to legacy IRQs */
+        pci_read_config_word(dev, 0x46, &temp);
+        temp |= 0xc000;
+        pci_write_config_word(dev, 0x46, temp);
+
+        /* Set i8259 interrupt trigger
+         * IRQ 3:  Level
+         * IRQ 4:  Level
+         * IRQ 5:  Level
+         * IRQ 6:  Level
+         * IRQ 7:  Level
+         * IRQ 9:  Level
+         * IRQ 10: Level
+         * IRQ 11: Level
+         * IRQ 12: Level
+         * IRQ 14: Edge
+         * IRQ 15: Edge
+         */
+        outb(0xfa, 0x4d0);
+        outb(0x1e, 0x4d1);
+}
+
+static void __devinit quirk_uli5288(struct pci_dev *dev)
+{
+        unsigned char c;
+
+        pci_read_config_byte(dev,0x83,&c);
+        c |= 0x80;
+        pci_write_config_byte(dev, 0x83, c);
+
+        pci_write_config_byte(dev, 0x09, 0x01);
+        pci_write_config_byte(dev, 0x0a, 0x06);
+
+        pci_read_config_byte(dev,0x83,&c);
+        c &= 0x7f;
+        pci_write_config_byte(dev, 0x83, c);
+
+        pci_read_config_byte(dev,0x84,&c);
+        c |= 0x01;
+        pci_write_config_byte(dev, 0x84, c);
+}
+
+static void __devinit quirk_uli5229(struct pci_dev *dev)
+{
+        unsigned short temp;
+        pci_write_config_word(dev, 0x04, 0x0405);
+        pci_read_config_word(dev, 0x4a, &temp);
+        temp |= 0x1000;
+        pci_write_config_word(dev, 0x4a, temp);
+}
+
+static void __devinit early_uli5249(struct pci_dev *dev)
+{
+        unsigned char temp;
+        pci_write_config_word(dev, 0x04, 0x0007);
+        pci_read_config_byte(dev, 0x7c, &temp);
+        pci_write_config_byte(dev, 0x7c, 0x80);
+        pci_write_config_byte(dev, 0x09, 0x01);
+        pci_write_config_byte(dev, 0x7c, temp);
+        dev->class |= 0x1;
+}
+
+DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_AL, 0x1575, quirk_ali1575);
+DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_AL, 0x5288, quirk_uli5288);
+DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_AL, 0x5229, quirk_uli5229);
+DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_AL, 0x5249, early_uli5249);
diff --git a/arch/powerpc/platforms/Makefile b/arch/powerpc/platforms/Makefile
index c4f6b0d2d140..292863694562 100644
--- a/arch/powerpc/platforms/Makefile
+++ b/arch/powerpc/platforms/Makefile
@@ -9,6 +9,7 @@ obj-$(CONFIG_PPC_CHRP)		+= chrp/
 obj-$(CONFIG_4xx)               += 4xx/
 obj-$(CONFIG_PPC_83xx)          += 83xx/
 obj-$(CONFIG_PPC_85xx)          += 85xx/
+obj-$(CONFIG_PPC_86xx)          += 86xx/
 obj-$(CONFIG_PPC_PSERIES)       += pseries/
 obj-$(CONFIG_PPC_ISERIES)       += iseries/
 obj-$(CONFIG_PPC_MAPLE)         += maple/
diff --git a/arch/powerpc/platforms/cell/Kconfig b/arch/powerpc/platforms/cell/Kconfig
index 6a02d51086c8..352bbbacde9a 100644
--- a/arch/powerpc/platforms/cell/Kconfig
+++ b/arch/powerpc/platforms/cell/Kconfig
@@ -5,15 +5,24 @@ config SPU_FS
         tristate "SPU file system"
         default m
         depends on PPC_CELL
+        select SPU_BASE
         help
           The SPU file system is used to access Synergistic Processing
           Units on machines implementing the Broadband Processor
           Architecture.
 
+config SPU_BASE
+        bool
+        default n
+
 config SPUFS_MMAP
         bool
         depends on SPU_FS && SPARSEMEM
         select MEMORY_HOTPLUG
         default y
 
+config CBE_RAS
+        bool "RAS features for bare metal Cell BE"
+        default y
+
 endmenu
diff --git a/arch/powerpc/platforms/cell/Makefile b/arch/powerpc/platforms/cell/Makefile
index e570bad06394..c89cdd67383b 100644
--- a/arch/powerpc/platforms/cell/Makefile
+++ b/arch/powerpc/platforms/cell/Makefile
@@ -1,16 +1,15 @@
-obj-y                   += interrupt.o iommu.o setup.o spider-pic.o
-obj-y                   += pervasive.o
+obj-$(CONFIG_PPC_CELL_NATIVE)           += interrupt.o iommu.o setup.o \
+                                           cbe_regs.o spider-pic.o pervasive.o
+obj-$(CONFIG_CBE_RAS)                   += ras.o
 
-obj-$(CONFIG_SMP)       += smp.o
-obj-$(CONFIG_SPU_FS)    += spu-base.o spufs/
-
-spu-base-y              += spu_base.o spu_priv1.o
+ifeq ($(CONFIG_SMP),y)
+obj-$(CONFIG_PPC_CELL_NATIVE)           += smp.o
+endif
 
 # needed only when building loadable spufs.ko
-spufs-modular-$(CONFIG_SPU_FS) += spu_syscalls.o
-obj-y                   += $(spufs-modular-m)
-
-# always needed in kernel
-spufs-builtin-$(CONFIG_SPU_FS) += spu_callbacks.o
-obj-y                   += $(spufs-builtin-y) $(spufs-builtin-m)
+spufs-modular-$(CONFIG_SPU_FS)          += spu_syscalls.o
+spu-priv1-$(CONFIG_PPC_CELL_NATIVE)     += spu_priv1_mmio.o
 
+obj-$(CONFIG_SPU_BASE)                  += spu_callbacks.o spu_base.o \
+                                           $(spufs-modular-m) \
+                                           $(spu-priv1-y) spufs/
diff --git a/arch/powerpc/platforms/cell/cbe_regs.c b/arch/powerpc/platforms/cell/cbe_regs.c
new file mode 100644
index 000000000000..2dfde61c8412
--- /dev/null
+++ b/arch/powerpc/platforms/cell/cbe_regs.c
@@ -0,0 +1,128 @@
+/*
+ * cbe_regs.c
+ *
+ * Accessor routines for the various MMIO register blocks of the CBE
+ *
+ * (c) 2006 Benjamin Herrenschmidt <benh@kernel.crashing.org>, IBM Corp.
+ */
+
+
+#include <linux/config.h>
+#include <linux/percpu.h>
+#include <linux/types.h>
+
+#include <asm/io.h>
+#include <asm/pgtable.h>
+#include <asm/prom.h>
+#include <asm/ptrace.h>
+
+#include "cbe_regs.h"
+
+#define MAX_CBE         2
+
+/*
+ * Current implementation uses "cpu" nodes. We build our own mapping
+ * array of cpu numbers to cpu nodes locally for now to allow interrupt
+ * time code to have a fast path rather than call of_get_cpu_node(). If
+ * we implement cpu hotplug, we'll have to install an appropriate norifier
+ * in order to release references to the cpu going away
+ */
+static struct cbe_regs_map
+{
+        struct device_node *cpu_node;
+        struct cbe_pmd_regs __iomem *pmd_regs;
+        struct cbe_iic_regs __iomem *iic_regs;
+} cbe_regs_maps[MAX_CBE];
+static int cbe_regs_map_count;
+
+static struct cbe_thread_map
+{
+        struct device_node *cpu_node;
+        struct cbe_regs_map *regs;
+} cbe_thread_map[NR_CPUS];
+
+static struct cbe_regs_map *cbe_find_map(struct device_node *np)
+{
+        int i;
+
+        for (i = 0; i < cbe_regs_map_count; i++)
+                if (cbe_regs_maps[i].cpu_node == np)
+                        return &cbe_regs_maps[i];
+        return NULL;
+}
+
+struct cbe_pmd_regs __iomem *cbe_get_pmd_regs(struct device_node *np)
+{
+        struct cbe_regs_map *map = cbe_find_map(np);
+        if (map == NULL)
+                return NULL;
+        return map->pmd_regs;
+}
+
+struct cbe_pmd_regs __iomem *cbe_get_cpu_pmd_regs(int cpu)
+{
+        struct cbe_regs_map *map = cbe_thread_map[cpu].regs;
+        if (map == NULL)
+                return NULL;
+        return map->pmd_regs;
+}
+
+
+struct cbe_iic_regs __iomem *cbe_get_iic_regs(struct device_node *np)
+{
+        struct cbe_regs_map *map = cbe_find_map(np);
+        if (map == NULL)
+                return NULL;
+        return map->iic_regs;
+}
+struct cbe_iic_regs __iomem *cbe_get_cpu_iic_regs(int cpu)
+{
+        struct cbe_regs_map *map = cbe_thread_map[cpu].regs;
+        if (map == NULL)
+                return NULL;
+        return map->iic_regs;
+}
+
+void __init cbe_regs_init(void)
+{
+        int i;
+        struct device_node *cpu;
+
+        /* Build local fast map of CPUs */
+        for_each_cpu(i)
+                cbe_thread_map[i].cpu_node = of_get_cpu_node(i, NULL);
+
+        /* Find maps for each device tree CPU */
+        for_each_node_by_type(cpu, "cpu") {
+                struct cbe_regs_map *map = &cbe_regs_maps[cbe_regs_map_count++];
+
+                /* That hack must die die die ! */
+                struct address_prop {
+                        unsigned long address;
+                        unsigned int len;
+                } __attribute__((packed)) *prop;
+
+
+                if (cbe_regs_map_count > MAX_CBE) {
+                        printk(KERN_ERR "cbe_regs: More BE chips than supported"
+                               "!\n");
+                        cbe_regs_map_count--;
+                        return;
+                }
+                map->cpu_node = cpu;
+                for_each_cpu(i)
+                        if (cbe_thread_map[i].cpu_node == cpu)
+                                cbe_thread_map[i].regs = map;
+
+                prop = (struct address_prop *)get_property(cpu, "pervasive",
+                                                           NULL);
+                if (prop != NULL)
+                        map->pmd_regs = ioremap(prop->address, prop->len);
+
+                prop = (struct address_prop *)get_property(cpu, "iic",
+                                                           NULL);
+                if (prop != NULL)
+                        map->iic_regs = ioremap(prop->address, prop->len);
+        }
+}
+
diff --git a/arch/powerpc/platforms/cell/cbe_regs.h b/arch/powerpc/platforms/cell/cbe_regs.h
new file mode 100644
index 000000000000..e76e4a6af5bc
--- /dev/null
+++ b/arch/powerpc/platforms/cell/cbe_regs.h
@@ -0,0 +1,129 @@
+/*
+ * cbe_regs.h
+ *
+ * This file is intended to hold the various register definitions for CBE
+ * on-chip system devices (memory controller, IO controller, etc...)
+ *
+ * (c) 2006 Benjamin Herrenschmidt <benh@kernel.crashing.org>, IBM Corp.
+ */
+
+#ifndef CBE_REGS_H
+#define CBE_REGS_H
+
+/*
+ *
+ * Some HID register definitions
+ *
+ */
+
+/* CBE specific HID0 bits */
+#define HID0_CBE_THERM_WAKEUP   0x0000020000000000ul
+#define HID0_CBE_SYSERR_WAKEUP  0x0000008000000000ul
+#define HID0_CBE_THERM_INT_EN   0x0000000400000000ul
+#define HID0_CBE_SYSERR_INT_EN  0x0000000200000000ul
+
+
+/*
+ *
+ * Pervasive unit register definitions
+ *
+ */
+
+struct cbe_pmd_regs {
+        u8 pad_0x0000_0x0800[0x0800 - 0x0000];                  /* 0x0000 */
+
+        /* Thermal Sensor Registers */
+        u64  ts_ctsr1;                                          /* 0x0800 */
+        u64  ts_ctsr2;                                          /* 0x0808 */
+        u64  ts_mtsr1;                                          /* 0x0810 */
+        u64  ts_mtsr2;                                          /* 0x0818 */
+        u64  ts_itr1;                                           /* 0x0820 */
+        u64  ts_itr2;                                           /* 0x0828 */
+        u64  ts_gitr;                                           /* 0x0830 */
+        u64  ts_isr;                                            /* 0x0838 */
+        u64  ts_imr;                                            /* 0x0840 */
+        u64  tm_cr1;                                            /* 0x0848 */
+        u64  tm_cr2;                                            /* 0x0850 */
+        u64  tm_simr;                                           /* 0x0858 */
+        u64  tm_tpr;                                            /* 0x0860 */
+        u64  tm_str1;                                           /* 0x0868 */
+        u64  tm_str2;                                           /* 0x0870 */
+        u64  tm_tsr;                                            /* 0x0878 */
+
+        /* Power Management */
+        u64  pm_control;                                        /* 0x0880 */
+#define CBE_PMD_PAUSE_ZERO_CONTROL              0x10000
+        u64  pm_status;                                         /* 0x0888 */
+
+        /* Time Base Register */
+        u64  tbr;                                               /* 0x0890 */
+
+        u8   pad_0x0898_0x0c00 [0x0c00 - 0x0898];               /* 0x0898 */
+
+        /* Fault Isolation Registers */
+        u64  checkstop_fir;                                     /* 0x0c00 */
+        u64  recoverable_fir;
+        u64  spec_att_mchk_fir;
+        u64  fir_mode_reg;
+        u64  fir_enable_mask;
+
+        u8   pad_0x0c28_0x1000 [0x1000 - 0x0c28];               /* 0x0c28 */
+};
+
+extern struct cbe_pmd_regs __iomem *cbe_get_pmd_regs(struct device_node *np);
+extern struct cbe_pmd_regs __iomem *cbe_get_cpu_pmd_regs(int cpu);
+
+/*
+ *
+ * IIC unit register definitions
+ *
+ */
+
+struct cbe_iic_pending_bits {
+        u32 data;
+        u8 flags;
+        u8 class;
+        u8 source;
+        u8 prio;
+};
+
+#define CBE_IIC_IRQ_VALID       0x80
+#define CBE_IIC_IRQ_IPI         0x40
+
+struct cbe_iic_thread_regs {
+        struct cbe_iic_pending_bits pending;
+        struct cbe_iic_pending_bits pending_destr;
+        u64 generate;
+        u64 prio;
+};
+
+struct cbe_iic_regs {
+        u8      pad_0x0000_0x0400[0x0400 - 0x0000];             /* 0x0000 */
+
+        /* IIC interrupt registers */
+        struct  cbe_iic_thread_regs thread[2];                  /* 0x0400 */
+        u64     iic_ir;                                         /* 0x0440 */
+        u64     iic_is;                                         /* 0x0448 */
+
+        u8      pad_0x0450_0x0500[0x0500 - 0x0450];             /* 0x0450 */
+
+        /* IOC FIR */
+        u64     ioc_fir_reset;                                  /* 0x0500 */
+        u64     ioc_fir_set;
+        u64     ioc_checkstop_enable;
+        u64     ioc_fir_error_mask;
+        u64     ioc_syserr_enable;
+        u64     ioc_fir;
+
+        u8      pad_0x0530_0x1000[0x1000 - 0x0530];             /* 0x0530 */
+};
+
+extern struct cbe_iic_regs __iomem *cbe_get_iic_regs(struct device_node *np);
+extern struct cbe_iic_regs __iomem *cbe_get_cpu_iic_regs(int cpu);
+
+
+/* Init this module early */
+extern void cbe_regs_init(void);
+
+
+#endif /* CBE_REGS_H */
diff --git a/arch/powerpc/platforms/cell/interrupt.c b/arch/powerpc/platforms/cell/interrupt.c
index 978be1c30c1b..f4e2d8805c9e 100644
--- a/arch/powerpc/platforms/cell/interrupt.c
+++ b/arch/powerpc/platforms/cell/interrupt.c
@@ -33,29 +33,10 @@
 #include <asm/ptrace.h>
 
 #include "interrupt.h"
-
-struct iic_pending_bits {
-        u32 data;
-        u8 flags;
-        u8 class;
-        u8 source;
-        u8 prio;
-};
-
-enum iic_pending_flags {
-        IIC_VALID = 0x80,
-        IIC_IPI   = 0x40,
-};
-
-struct iic_regs {
-        struct iic_pending_bits pending;
-        struct iic_pending_bits pending_destr;
-        u64 generate;
-        u64 prio;
-};
+#include "cbe_regs.h"
 
 struct iic {
-        struct iic_regs __iomem *regs;
+        struct cbe_iic_thread_regs __iomem *regs;
         u8 target_id;
 };
 
@@ -115,7 +96,7 @@ static struct hw_interrupt_type iic_pic = {
         .end = iic_end,
 };
 
-static int iic_external_get_irq(struct iic_pending_bits pending)
+static int iic_external_get_irq(struct cbe_iic_pending_bits pending)
 {
         int irq;
         unsigned char node, unit;
@@ -136,8 +117,7 @@ static int iic_external_get_irq(struct iic_pending_bits pending)
                  * One of these units can be connected
                  * to an external interrupt controller.
                  */
-                if (pending.prio > 0x3f ||
-                    pending.class != 2)
+                if (pending.class != 2)
                         break;
                 irq = IIC_EXT_OFFSET
                         + spider_get_irq(node)
@@ -168,15 +148,15 @@ int iic_get_irq(struct pt_regs *regs)
 {
         struct iic *iic;
         int irq;
-        struct iic_pending_bits pending;
+        struct cbe_iic_pending_bits pending;
 
         iic = &__get_cpu_var(iic);
         *(unsigned long *) &pending = 
                 in_be64((unsigned long __iomem *) &iic->regs->pending_destr);
 
         irq = -1;
-        if (pending.flags & IIC_VALID) {
-                if (pending.flags & IIC_IPI) {
+        if (pending.flags & CBE_IIC_IRQ_VALID) {
+                if (pending.flags & CBE_IIC_IRQ_IPI) {
                         irq = IIC_IPI_OFFSET + (pending.prio >> 4);
 /*
                         if (irq > 0x80)
@@ -226,7 +206,7 @@ static int setup_iic_hardcoded(void)
                         regs += 0x20;
 
                 printk(KERN_INFO "IIC for CPU %d at %lx\n", cpu, regs);
-                iic->regs = ioremap(regs, sizeof(struct iic_regs));
+                iic->regs = ioremap(regs, sizeof(struct cbe_iic_thread_regs));
                 iic->target_id = (nodeid << 4) + ((cpu & 1) ? 0xf : 0xe);
         }
 
@@ -267,12 +247,12 @@ static int setup_iic(void)
                 }
 
                 iic = &per_cpu(iic, np[0]);
-                iic->regs = ioremap(regs[0], sizeof(struct iic_regs));
+                iic->regs = ioremap(regs[0], sizeof(struct cbe_iic_thread_regs));
                 iic->target_id = ((np[0] & 2) << 3) + ((np[0] & 1) ? 0xf : 0xe);
                 printk("IIC for CPU %d at %lx mapped to %p\n", np[0], regs[0], iic->regs);
 
                 iic = &per_cpu(iic, np[1]);
-                iic->regs = ioremap(regs[2], sizeof(struct iic_regs));
+                iic->regs = ioremap(regs[2], sizeof(struct cbe_iic_thread_regs));
                 iic->target_id = ((np[1] & 2) << 3) + ((np[1] & 1) ? 0xf : 0xe);
                 printk("IIC for CPU %d at %lx mapped to %p\n", np[1], regs[2], iic->regs);
 
diff --git a/arch/powerpc/platforms/cell/iommu.c b/arch/powerpc/platforms/cell/iommu.c
index a49ceb799a8e..a35004e14c69 100644
--- a/arch/powerpc/platforms/cell/iommu.c
+++ b/arch/powerpc/platforms/cell/iommu.c
@@ -473,6 +473,16 @@ static int cell_dma_supported(struct device *dev, u64 mask)
         return mask < 0x100000000ull;
 }
 
+static struct dma_mapping_ops cell_iommu_ops = {
+        .alloc_coherent = cell_alloc_coherent,
+        .free_coherent = cell_free_coherent,
+        .map_single = cell_map_single,
+        .unmap_single = cell_unmap_single,
+        .map_sg = cell_map_sg,
+        .unmap_sg = cell_unmap_sg,
+        .dma_supported = cell_dma_supported,
+};
+
 void cell_init_iommu(void)
 {
         int setup_bus = 0;
@@ -498,11 +508,5 @@ void cell_init_iommu(void)
                 }
         }
 
-        pci_dma_ops.alloc_coherent = cell_alloc_coherent;
-        pci_dma_ops.free_coherent = cell_free_coherent;
-        pci_dma_ops.map_single = cell_map_single;
-        pci_dma_ops.unmap_single = cell_unmap_single;
-        pci_dma_ops.map_sg = cell_map_sg;
-        pci_dma_ops.unmap_sg = cell_unmap_sg;
-        pci_dma_ops.dma_supported = cell_dma_supported;
+        pci_dma_ops = cell_iommu_ops;
 }
diff --git a/arch/powerpc/platforms/cell/pervasive.c b/arch/powerpc/platforms/cell/pervasive.c
index 7eed8c624517..695ac4e1617e 100644
--- a/arch/powerpc/platforms/cell/pervasive.c
+++ b/arch/powerpc/platforms/cell/pervasive.c
@@ -37,36 +37,28 @@
 #include <asm/reg.h>
 
 #include "pervasive.h"
+#include "cbe_regs.h"
 
 static DEFINE_SPINLOCK(cbe_pervasive_lock);
-struct cbe_pervasive {
-        struct pmd_regs __iomem *regs;
-        unsigned int thread;
-};
-
-/* can't use per_cpu from setup_arch */
-static struct cbe_pervasive cbe_pervasive[NR_CPUS];
 
 static void __init cbe_enable_pause_zero(void)
 {
         unsigned long thread_switch_control;
         unsigned long temp_register;
-        struct cbe_pervasive *p;
-        int thread;
+        struct cbe_pmd_regs __iomem *pregs;
 
         spin_lock_irq(&cbe_pervasive_lock);
-        p = &cbe_pervasive[smp_processor_id()];
-
-        if (!cbe_pervasive->regs)
+        pregs = cbe_get_cpu_pmd_regs(smp_processor_id());
+        if (pregs == NULL)
                 goto out;
 
         pr_debug("Power Management: CPU %d\n", smp_processor_id());
 
          /* Enable Pause(0) control bit */
-        temp_register = in_be64(&p->regs->pm_control);
+        temp_register = in_be64(&pregs->pm_control);
 
-        out_be64(&p->regs->pm_control,
-                 temp_register|PMD_PAUSE_ZERO_CONTROL);
+        out_be64(&pregs->pm_control,
+                 temp_register | CBE_PMD_PAUSE_ZERO_CONTROL);
 
         /* Enable DEC and EE interrupt request */
         thread_switch_control  = mfspr(SPRN_TSC_CELL);
@@ -75,25 +67,16 @@ static void __init cbe_enable_pause_zero(void)
         switch ((mfspr(SPRN_CTRLF) & CTRL_CT)) {
         case CTRL_CT0:
                 thread_switch_control |= TSC_CELL_DEC_ENABLE_0;
-                thread = 0;
                 break;
         case CTRL_CT1:
                 thread_switch_control |= TSC_CELL_DEC_ENABLE_1;
-                thread = 1;
                 break;
         default:
                 printk(KERN_WARNING "%s: unknown configuration\n",
                         __FUNCTION__);
-                thread = -1;
                 break;
         }
 
-        if (p->thread != thread)
-                printk(KERN_WARNING "%s: device tree inconsistant, "
-                                     "cpu %i: %d/%d\n", __FUNCTION__,
-                                     smp_processor_id(),
-                                     p->thread, thread);
-
         mtspr(SPRN_TSC_CELL, thread_switch_control);
 
 out:
@@ -104,6 +87,11 @@ static void cbe_idle(void)
 {
         unsigned long ctrl;
 
+        /* Why do we do that on every idle ? Couldn't that be done once for
+         * all or do we lose the state some way ? Also, the pm_control
+         * register setting, that can't be set once at boot ? We really want
+         * to move that away in order to implement a simple powersave
+         */
         cbe_enable_pause_zero();
 
         while (1) {
@@ -152,8 +140,15 @@ static int cbe_system_reset_exception(struct pt_regs *regs)
                 timer_interrupt(regs);
                 break;
         case SRR1_WAKEMT:
-                /* no action required */
                 break;
+#ifdef CONFIG_CBE_RAS
+        case SRR1_WAKESYSERR:
+                cbe_system_error_exception(regs);
+                break;
+        case SRR1_WAKETHERM:
+                cbe_thermal_exception(regs);
+                break;
+#endif /* CONFIG_CBE_RAS */
         default:
                 /* do system reset */
                 return 0;
@@ -162,68 +157,11 @@ static int cbe_system_reset_exception(struct pt_regs *regs)
         return 1;
 }
 
-static int __init cbe_find_pmd_mmio(int cpu, struct cbe_pervasive *p)
-{
-        struct device_node *node;
-        unsigned int *int_servers;
-        char *addr;
-        unsigned long real_address;
-        unsigned int size;
-
-        struct pmd_regs __iomem *pmd_mmio_area;
-        int hardid, thread;
-        int proplen;
-
-        pmd_mmio_area = NULL;
-        hardid = get_hard_smp_processor_id(cpu);
-        for (node = NULL; (node = of_find_node_by_type(node, "cpu"));) {
-                int_servers = (void *) get_property(node,
-                                "ibm,ppc-interrupt-server#s", &proplen);
-                if (!int_servers) {
-                        printk(KERN_WARNING "%s misses "
-                                "ibm,ppc-interrupt-server#s property",
-                                node->full_name);
-                        continue;
-                }
-                for (thread = 0; thread < proplen / sizeof (int); thread++) {
-                        if (hardid == int_servers[thread]) {
-                                addr = get_property(node, "pervasive", NULL);
-                                goto found;
-                        }
-                }
-        }
-
-        printk(KERN_WARNING "%s: CPU %d not found\n", __FUNCTION__, cpu);
-        return -EINVAL;
-
-found:
-        real_address = *(unsigned long*) addr;
-        addr += sizeof (unsigned long);
-        size = *(unsigned int*) addr;
-
-        pr_debug("pervasive area for CPU %d at %lx, size %x\n",
-                        cpu, real_address, size);
-        p->regs = ioremap(real_address, size);
-        p->thread = thread;
-        return 0;
-}
-
-void __init cell_pervasive_init(void)
+void __init cbe_pervasive_init(void)
 {
-        struct cbe_pervasive *p;
-        int cpu;
-        int ret;
-
         if (!cpu_has_feature(CPU_FTR_PAUSE_ZERO))
                 return;
 
-        for_each_possible_cpu(cpu) {
-                p = &cbe_pervasive[cpu];
-                ret = cbe_find_pmd_mmio(cpu, p);
-                if (ret)
-                        return;
-        }
-
         ppc_md.idle_loop = cbe_idle;
         ppc_md.system_reset_exception = cbe_system_reset_exception;
 }
diff --git a/arch/powerpc/platforms/cell/pervasive.h b/arch/powerpc/platforms/cell/pervasive.h
index da1fb85ca3e8..7b50947f8044 100644
--- a/arch/powerpc/platforms/cell/pervasive.h
+++ b/arch/powerpc/platforms/cell/pervasive.h
@@ -25,38 +25,9 @@
 #ifndef PERVASIVE_H
 #define PERVASIVE_H
 
-struct pmd_regs {
-        u8 pad_0x0000_0x0800[0x0800 - 0x0000];                  /* 0x0000 */
-
-        /* Thermal Sensor Registers */
-        u64  ts_ctsr1;                                          /* 0x0800 */
-        u64  ts_ctsr2;                                          /* 0x0808 */
-        u64  ts_mtsr1;                                          /* 0x0810 */
-        u64  ts_mtsr2;                                          /* 0x0818 */
-        u64  ts_itr1;                                           /* 0x0820 */
-        u64  ts_itr2;                                           /* 0x0828 */
-        u64  ts_gitr;                                           /* 0x0830 */
-        u64  ts_isr;                                            /* 0x0838 */
-        u64  ts_imr;                                            /* 0x0840 */
-        u64  tm_cr1;                                            /* 0x0848 */
-        u64  tm_cr2;                                            /* 0x0850 */
-        u64  tm_simr;                                           /* 0x0858 */
-        u64  tm_tpr;                                            /* 0x0860 */
-        u64  tm_str1;                                           /* 0x0868 */
-        u64  tm_str2;                                           /* 0x0870 */
-        u64  tm_tsr;                                            /* 0x0878 */
-
-        /* Power Management */
-        u64  pm_control;                                        /* 0x0880 */
-#define PMD_PAUSE_ZERO_CONTROL          0x10000
-        u64  pm_status;                                         /* 0x0888 */
-
-        /* Time Base Register */
-        u64  tbr;                                               /* 0x0890 */
-
-        u8   pad_0x0898_0x1000 [0x1000 - 0x0898];               /* 0x0898 */
-};
-
-void __init cell_pervasive_init(void);
+extern void cbe_pervasive_init(void);
+extern void cbe_system_error_exception(struct pt_regs *regs);
+extern void cbe_maintenance_exception(struct pt_regs *regs);
+extern void cbe_thermal_exception(struct pt_regs *regs);
 
 #endif
diff --git a/arch/powerpc/platforms/cell/ras.c b/arch/powerpc/platforms/cell/ras.c
new file mode 100644
index 000000000000..033ad6e2827b
--- /dev/null
+++ b/arch/powerpc/platforms/cell/ras.c
@@ -0,0 +1,112 @@
+#define DEBUG
+
+#include <linux/config.h>
+#include <linux/types.h>
+#include <linux/kernel.h>
+#include <linux/smp.h>
+
+#include <asm/reg.h>
+#include <asm/io.h>
+#include <asm/prom.h>
+#include <asm/machdep.h>
+
+#include "ras.h"
+#include "cbe_regs.h"
+
+
+static void dump_fir(int cpu)
+{
+        struct cbe_pmd_regs __iomem *pregs = cbe_get_cpu_pmd_regs(cpu);
+        struct cbe_iic_regs __iomem *iregs = cbe_get_cpu_iic_regs(cpu);
+
+        if (pregs == NULL)
+                return;
+
+        /* Todo: do some nicer parsing of bits and based on them go down
+         * to other sub-units FIRs and not only IIC
+         */
+        printk(KERN_ERR "Global Checkstop FIR    : 0x%016lx\n",
+               in_be64(&pregs->checkstop_fir));
+        printk(KERN_ERR "Global Recoverable FIR  : 0x%016lx\n",
+               in_be64(&pregs->checkstop_fir));
+        printk(KERN_ERR "Global MachineCheck FIR : 0x%016lx\n",
+               in_be64(&pregs->spec_att_mchk_fir));
+
+        if (iregs == NULL)
+                return;
+        printk(KERN_ERR "IOC FIR                 : 0x%016lx\n",
+               in_be64(&iregs->ioc_fir));
+
+}
+
+void cbe_system_error_exception(struct pt_regs *regs)
+{
+        int cpu = smp_processor_id();
+
+        printk(KERN_ERR "System Error Interrupt on CPU %d !\n", cpu);
+        dump_fir(cpu);
+        dump_stack();
+}
+
+void cbe_maintenance_exception(struct pt_regs *regs)
+{
+        int cpu = smp_processor_id();
+
+        /*
+         * Nothing implemented for the maintenance interrupt at this point
+         */
+
+        printk(KERN_ERR "Unhandled Maintenance interrupt on CPU %d !\n", cpu);
+        dump_stack();
+}
+
+void cbe_thermal_exception(struct pt_regs *regs)
+{
+        int cpu = smp_processor_id();
+
+        /*
+         * Nothing implemented for the thermal interrupt at this point
+         */
+
+        printk(KERN_ERR "Unhandled Thermal interrupt on CPU %d !\n", cpu);
+        dump_stack();
+}
+
+static int cbe_machine_check_handler(struct pt_regs *regs)
+{
+        int cpu = smp_processor_id();
+
+        printk(KERN_ERR "Machine Check Interrupt on CPU %d !\n", cpu);
+        dump_fir(cpu);
+
+        /* No recovery from this code now, lets continue */
+        return 0;
+}
+
+void __init cbe_ras_init(void)
+{
+        unsigned long hid0;
+
+        /*
+         * Enable System Error & thermal interrupts and wakeup conditions
+         */
+
+        hid0 = mfspr(SPRN_HID0);
+        hid0 |= HID0_CBE_THERM_INT_EN | HID0_CBE_THERM_WAKEUP |
+                HID0_CBE_SYSERR_INT_EN | HID0_CBE_SYSERR_WAKEUP;
+        mtspr(SPRN_HID0, hid0);
+        mb();
+
+        /*
+         * Install machine check handler. Leave setting of precise mode to
+         * what the firmware did for now
+         */
+        ppc_md.machine_check_exception = cbe_machine_check_handler;
+        mb();
+
+        /*
+         * For now, we assume that IOC_FIR is already set to forward some
+         * error conditions to the System Error handler. If that is not true
+         * then it will have to be fixed up here.
+         */
+}
diff --git a/arch/powerpc/platforms/cell/ras.h b/arch/powerpc/platforms/cell/ras.h
new file mode 100644
index 000000000000..eb7ee54c82a0
--- /dev/null
+++ b/arch/powerpc/platforms/cell/ras.h
@@ -0,0 +1,9 @@
+#ifndef RAS_H
+#define RAS_H
+
+extern void cbe_system_error_exception(struct pt_regs *regs);
+extern void cbe_maintenance_exception(struct pt_regs *regs);
+extern void cbe_thermal_exception(struct pt_regs *regs);
+extern void cbe_ras_init(void);
+
+#endif /* RAS_H */
diff --git a/arch/powerpc/platforms/cell/setup.c b/arch/powerpc/platforms/cell/setup.c
index fd3e5609e3e0..3d1831d331e5 100644
--- a/arch/powerpc/platforms/cell/setup.c
+++ b/arch/powerpc/platforms/cell/setup.c
@@ -49,10 +49,13 @@
 #include <asm/ppc-pci.h>
 #include <asm/irq.h>
 #include <asm/spu.h>
+#include <asm/spu_priv1.h>
 
 #include "interrupt.h"
 #include "iommu.h"
+#include "cbe_regs.h"
 #include "pervasive.h"
+#include "ras.h"
 
 #ifdef DEBUG
 #define DBG(fmt...) udbg_printf(fmt)
@@ -81,6 +84,15 @@ static void __init cell_setup_arch(void)
 {
         ppc_md.init_IRQ       = iic_init_IRQ;
         ppc_md.get_irq        = iic_get_irq;
+#ifdef CONFIG_SPU_BASE
+        spu_priv1_ops         = &spu_priv1_mmio_ops;
+#endif
+
+        cbe_regs_init();
+
+#ifdef CONFIG_CBE_RAS
+        cbe_ras_init();
+#endif
 
 #ifdef CONFIG_SMP
         smp_init_cell();
@@ -98,7 +110,7 @@ static void __init cell_setup_arch(void)
         init_pci_config_tokens();
         find_and_init_phbs();
         spider_init_IRQ();
-        cell_pervasive_init();
+        cbe_pervasive_init();
 #ifdef CONFIG_DUMMY_CONSOLE
         conswitchp = &dummy_con;
 #endif
diff --git a/arch/powerpc/platforms/cell/spu_base.c b/arch/powerpc/platforms/cell/spu_base.c
index ad141fe8d52d..db82f503ba2c 100644
--- a/arch/powerpc/platforms/cell/spu_base.c
+++ b/arch/powerpc/platforms/cell/spu_base.c
@@ -34,10 +34,15 @@
 #include <asm/prom.h>
 #include <linux/mutex.h>
 #include <asm/spu.h>
+#include <asm/spu_priv1.h>
 #include <asm/mmu_context.h>
 
 #include "interrupt.h"
 
+const struct spu_priv1_ops *spu_priv1_ops;
+
+EXPORT_SYMBOL_GPL(spu_priv1_ops);
+
 static int __spu_trap_invalid_dma(struct spu *spu)
 {
         pr_debug("%s\n", __FUNCTION__);
@@ -71,7 +76,7 @@ static int __spu_trap_data_seg(struct spu *spu, unsigned long ea)
 {
         struct spu_priv2 __iomem *priv2 = spu->priv2;
         struct mm_struct *mm = spu->mm;
-        u64 esid, vsid;
+        u64 esid, vsid, llp;
 
         pr_debug("%s\n", __FUNCTION__);
 
@@ -91,9 +96,14 @@ static int __spu_trap_data_seg(struct spu *spu, unsigned long ea)
         }
 
         esid = (ea & ESID_MASK) | SLB_ESID_V;
-        vsid = (get_vsid(mm->context.id, ea) << SLB_VSID_SHIFT) | SLB_VSID_USER;
+#ifdef CONFIG_HUGETLB_PAGE
         if (in_hugepage_area(mm->context, ea))
-                vsid |= SLB_VSID_L;
+                llp = mmu_psize_defs[mmu_huge_psize].sllp;
+        else
+#endif
+                llp = mmu_psize_defs[mmu_virtual_psize].sllp;
+        vsid = (get_vsid(mm->context.id, ea) << SLB_VSID_SHIFT) |
+                        SLB_VSID_USER | llp;
 
         out_be64(&priv2->slb_index_W, spu->slb_replace);
         out_be64(&priv2->slb_vsid_RW, vsid);
@@ -130,57 +140,7 @@ static int __spu_trap_data_map(struct spu *spu, unsigned long ea, u64 dsisr)
         spu->dar = ea;
         spu->dsisr = dsisr;
         mb();
-        if (spu->stop_callback)
-                spu->stop_callback(spu);
-        return 0;
-}
-
-static int __spu_trap_mailbox(struct spu *spu)
-{
-        if (spu->ibox_callback)
-                spu->ibox_callback(spu);
-
-        /* atomically disable SPU mailbox interrupts */
-        spin_lock(&spu->register_lock);
-        spu_int_mask_and(spu, 2, ~0x1);
-        spin_unlock(&spu->register_lock);
-        return 0;
-}
-
-static int __spu_trap_stop(struct spu *spu)
-{
-        pr_debug("%s\n", __FUNCTION__);
-        spu->stop_code = in_be32(&spu->problem->spu_status_R);
-        if (spu->stop_callback)
-                spu->stop_callback(spu);
-        return 0;
-}
-
-static int __spu_trap_halt(struct spu *spu)
-{
-        pr_debug("%s\n", __FUNCTION__);
-        spu->stop_code = in_be32(&spu->problem->spu_status_R);
-        if (spu->stop_callback)
-                spu->stop_callback(spu);
-        return 0;
-}
-
-static int __spu_trap_tag_group(struct spu *spu)
-{
-        pr_debug("%s\n", __FUNCTION__);
-        spu->mfc_callback(spu);
-        return 0;
-}
-
-static int __spu_trap_spubox(struct spu *spu)
-{
-        if (spu->wbox_callback)
-                spu->wbox_callback(spu);
-
-        /* atomically disable SPU mailbox interrupts */
-        spin_lock(&spu->register_lock);
-        spu_int_mask_and(spu, 2, ~0x10);
-        spin_unlock(&spu->register_lock);
+        spu->stop_callback(spu);
         return 0;
 }
 
@@ -191,8 +151,7 @@ spu_irq_class_0(int irq, void *data, struct pt_regs *regs)
 
         spu = data;
         spu->class_0_pending = 1;
-        if (spu->stop_callback)
-                spu->stop_callback(spu);
+        spu->stop_callback(spu);
 
         return IRQ_HANDLED;
 }
@@ -270,29 +229,38 @@ spu_irq_class_2(int irq, void *data, struct pt_regs *regs)
         unsigned long mask;
 
         spu = data;
+        spin_lock(&spu->register_lock);
         stat = spu_int_stat_get(spu, 2);
         mask = spu_int_mask_get(spu, 2);
+        /* ignore interrupts we're not waiting for */
+        stat &= mask;
+        /*
+         * mailbox interrupts (0x1 and 0x10) are level triggered.
+         * mask them now before acknowledging.
+         */
+        if (stat & 0x11)
+                spu_int_mask_and(spu, 2, ~(stat & 0x11));
+        /* acknowledge all interrupts before the callbacks */
+        spu_int_stat_clear(spu, 2, stat);
+        spin_unlock(&spu->register_lock);
 
         pr_debug("class 2 interrupt %d, %lx, %lx\n", irq, stat, mask);
 
-        stat &= mask;
-
         if (stat & 1)  /* PPC core mailbox */
-                __spu_trap_mailbox(spu);
+                spu->ibox_callback(spu);
 
         if (stat & 2) /* SPU stop-and-signal */
-                __spu_trap_stop(spu);
+                spu->stop_callback(spu);
 
         if (stat & 4) /* SPU halted */
-                __spu_trap_halt(spu);
+                spu->stop_callback(spu);
 
         if (stat & 8) /* DMA tag group complete */
-                __spu_trap_tag_group(spu);
+                spu->mfc_callback(spu);
 
         if (stat & 0x10) /* SPU mailbox threshold */
-                __spu_trap_spubox(spu);
+                spu->wbox_callback(spu);
 
-        spu_int_stat_clear(spu, 2, stat);
         return stat ? IRQ_HANDLED : IRQ_NONE;
 }
 
@@ -512,14 +480,6 @@ int spu_irq_class_1_bottom(struct spu *spu)
         return ret;
 }
 
-void spu_irq_setaffinity(struct spu *spu, int cpu)
-{
-        u64 target = iic_get_target_id(cpu);
-        u64 route = target << 48 | target << 32 | target << 16;
-        spu_int_route_set(spu, route);
-}
-EXPORT_SYMBOL_GPL(spu_irq_setaffinity);
-
 static int __init find_spu_node_id(struct device_node *spe)
 {
         unsigned int *id;
@@ -649,6 +609,46 @@ out:
         return ret;
 }
 
+struct sysdev_class spu_sysdev_class = {
+        set_kset_name("spu")
+};
+
+static ssize_t spu_show_isrc(struct sys_device *sysdev, char *buf)
+{
+        struct spu *spu = container_of(sysdev, struct spu, sysdev);
+        return sprintf(buf, "%d\n", spu->isrc);
+
+}
+static SYSDEV_ATTR(isrc, 0400, spu_show_isrc, NULL);
+
+extern int attach_sysdev_to_node(struct sys_device *dev, int nid);
+
+static int spu_create_sysdev(struct spu *spu)
+{
+        int ret;
+
+        spu->sysdev.id = spu->number;
+        spu->sysdev.cls = &spu_sysdev_class;
+        ret = sysdev_register(&spu->sysdev);
+        if (ret) {
+                printk(KERN_ERR "Can't register SPU %d with sysfs\n",
+                                spu->number);
+                return ret;
+        }
+
+        sysdev_create_file(&spu->sysdev, &attr_isrc);
+        sysfs_add_device_to_node(&spu->sysdev, spu->nid);
+
+        return 0;
+}
+
+static void spu_destroy_sysdev(struct spu *spu)
+{
+        sysdev_remove_file(&spu->sysdev, &attr_isrc);
+        sysfs_remove_device_from_node(&spu->sysdev, spu->nid);
+        sysdev_unregister(&spu->sysdev);
+}
+
 static int __init create_spu(struct device_node *spe)
 {
         struct spu *spu;
@@ -656,7 +656,7 @@ static int __init create_spu(struct device_node *spe)
         static int number;
 
         ret = -ENOMEM;
-        spu = kmalloc(sizeof (*spu), GFP_KERNEL);
+        spu = kzalloc(sizeof (*spu), GFP_KERNEL);
         if (!spu)
                 goto out;
 
@@ -668,33 +668,20 @@ static int __init create_spu(struct device_node *spe)
         spu->nid = of_node_to_nid(spe);
         if (spu->nid == -1)
                 spu->nid = 0;
-
-        spu->stop_code = 0;
-        spu->slb_replace = 0;
-        spu->mm = NULL;
-        spu->ctx = NULL;
-        spu->rq = NULL;
-        spu->pid = 0;
-        spu->class_0_pending = 0;
-        spu->flags = 0UL;
-        spu->dar = 0UL;
-        spu->dsisr = 0UL;
         spin_lock_init(&spu->register_lock);
-
         spu_mfc_sdr_set(spu, mfspr(SPRN_SDR1));
         spu_mfc_sr1_set(spu, 0x33);
-
-        spu->ibox_callback = NULL;
-        spu->wbox_callback = NULL;
-        spu->stop_callback = NULL;
-        spu->mfc_callback = NULL;
-
         mutex_lock(&spu_mutex);
+
         spu->number = number++;
         ret = spu_request_irqs(spu);
         if (ret)
                 goto out_unmap;
 
+        ret = spu_create_sysdev(spu);
+        if (ret)
+                goto out_free_irqs;
+
         list_add(&spu->list, &spu_list);
         mutex_unlock(&spu_mutex);
 
@@ -703,6 +690,9 @@ static int __init create_spu(struct device_node *spe)
                 spu->problem, spu->priv1, spu->priv2, spu->number);
         goto out;
 
+out_free_irqs:
+        spu_free_irqs(spu);
+
 out_unmap:
         mutex_unlock(&spu_mutex);
         spu_unmap(spu);
@@ -716,6 +706,7 @@ static void destroy_spu(struct spu *spu)
 {
         list_del_init(&spu->list);
 
+        spu_destroy_sysdev(spu);
         spu_free_irqs(spu);
         spu_unmap(spu);
         kfree(spu);
@@ -728,6 +719,7 @@ static void cleanup_spu_base(void)
         list_for_each_entry_safe(spu, tmp, &spu_list, list)
                 destroy_spu(spu);
         mutex_unlock(&spu_mutex);
+        sysdev_class_unregister(&spu_sysdev_class);
 }
 module_exit(cleanup_spu_base);
 
@@ -736,6 +728,11 @@ static int __init init_spu_base(void)
         struct device_node *node;
         int ret;
 
+        /* create sysdev class for spus */
+        ret = sysdev_class_register(&spu_sysdev_class);
+        if (ret)
+                return ret;
+
         ret = -ENODEV;
         for (node = of_find_node_by_type(NULL, "spe");
                         node; node = of_find_node_by_type(node, "spe")) {
diff --git a/arch/powerpc/platforms/cell/spu_callbacks.c b/arch/powerpc/platforms/cell/spu_callbacks.c
index b47fcc5ddb78..47ec3be3edcd 100644
--- a/arch/powerpc/platforms/cell/spu_callbacks.c
+++ b/arch/powerpc/platforms/cell/spu_callbacks.c
@@ -34,307 +34,19 @@
  */
 
 void *spu_syscall_table[] = {
-        [__NR_restart_syscall]          sys_ni_syscall, /* sys_restart_syscall */
-        [__NR_exit]                     sys_ni_syscall, /* sys_exit */
-        [__NR_fork]                     sys_ni_syscall, /* ppc_fork */
-        [__NR_read]                     sys_read,
-        [__NR_write]                    sys_write,
-        [__NR_open]                     sys_open,
-        [__NR_close]                    sys_close,
-        [__NR_waitpid]                  sys_waitpid,
-        [__NR_creat]                    sys_creat,
-        [__NR_link]                     sys_link,
-        [__NR_unlink]                   sys_unlink,
-        [__NR_execve]                   sys_ni_syscall, /* sys_execve */
-        [__NR_chdir]                    sys_chdir,
-        [__NR_time]                     sys_time,
-        [__NR_mknod]                    sys_mknod,
-        [__NR_chmod]                    sys_chmod,
-        [__NR_lchown]                   sys_lchown,
-        [__NR_break]                    sys_ni_syscall,
-        [__NR_oldstat]                  sys_ni_syscall,
-        [__NR_lseek]                    sys_lseek,
-        [__NR_getpid]                   sys_getpid,
-        [__NR_mount]                    sys_ni_syscall, /* sys_mount */
-        [__NR_umount]                   sys_ni_syscall,
-        [__NR_setuid]                   sys_setuid,
-        [__NR_getuid]                   sys_getuid,
-        [__NR_stime]                    sys_stime,
-        [__NR_ptrace]                   sys_ni_syscall, /* sys_ptrace */
-        [__NR_alarm]                    sys_alarm,
-        [__NR_oldfstat]                 sys_ni_syscall,
-        [__NR_pause]                    sys_ni_syscall, /* sys_pause */
-        [__NR_utime]                    sys_ni_syscall, /* sys_utime */
-        [__NR_stty]                     sys_ni_syscall,
-        [__NR_gtty]                     sys_ni_syscall,
-        [__NR_access]                   sys_access,
-        [__NR_nice]                     sys_nice,
-        [__NR_ftime]                    sys_ni_syscall,
-        [__NR_sync]                     sys_sync,
-        [__NR_kill]                     sys_kill,
-        [__NR_rename]                   sys_rename,
-        [__NR_mkdir]                    sys_mkdir,
-        [__NR_rmdir]                    sys_rmdir,
-        [__NR_dup]                      sys_dup,
-        [__NR_pipe]                     sys_pipe,
-        [__NR_times]                    sys_times,
-        [__NR_prof]                     sys_ni_syscall,
-        [__NR_brk]                      sys_brk,
-        [__NR_setgid]                   sys_setgid,
-        [__NR_getgid]                   sys_getgid,
-        [__NR_signal]                   sys_ni_syscall, /* sys_signal */
-        [__NR_geteuid]                  sys_geteuid,
-        [__NR_getegid]                  sys_getegid,
-        [__NR_acct]                     sys_ni_syscall, /* sys_acct */
-        [__NR_umount2]                  sys_ni_syscall, /* sys_umount */
-        [__NR_lock]                     sys_ni_syscall,
-        [__NR_ioctl]                    sys_ioctl,
-        [__NR_fcntl]                    sys_fcntl,
-        [__NR_mpx]                      sys_ni_syscall,
-        [__NR_setpgid]                  sys_setpgid,
-        [__NR_ulimit]                   sys_ni_syscall,
-        [__NR_oldolduname]              sys_ni_syscall,
-        [__NR_umask]                    sys_umask,
-        [__NR_chroot]                   sys_chroot,
-        [__NR_ustat]                    sys_ni_syscall, /* sys_ustat */
-        [__NR_dup2]                     sys_dup2,
-        [__NR_getppid]                  sys_getppid,
-        [__NR_getpgrp]                  sys_getpgrp,
-        [__NR_setsid]                   sys_setsid,
-        [__NR_sigaction]                sys_ni_syscall,
-        [__NR_sgetmask]                 sys_sgetmask,
-        [__NR_ssetmask]                 sys_ssetmask,
-        [__NR_setreuid]                 sys_setreuid,
-        [__NR_setregid]                 sys_setregid,
-        [__NR_sigsuspend]               sys_ni_syscall,
-        [__NR_sigpending]               sys_ni_syscall,
-        [__NR_sethostname]              sys_sethostname,
-        [__NR_setrlimit]                sys_setrlimit,
-        [__NR_getrlimit]                sys_ni_syscall,
-        [__NR_getrusage]                sys_getrusage,
-        [__NR_gettimeofday]             sys_gettimeofday,
-        [__NR_settimeofday]             sys_settimeofday,
-        [__NR_getgroups]                sys_getgroups,
-        [__NR_setgroups]                sys_setgroups,
-        [__NR_select]                   sys_ni_syscall,
-        [__NR_symlink]                  sys_symlink,
-        [__NR_oldlstat]                 sys_ni_syscall,
-        [__NR_readlink]                 sys_readlink,
-        [__NR_uselib]                   sys_ni_syscall, /* sys_uselib */
-        [__NR_swapon]                   sys_ni_syscall, /* sys_swapon */
-        [__NR_reboot]                   sys_ni_syscall, /* sys_reboot */
-        [__NR_readdir]                  sys_ni_syscall,
-        [__NR_mmap]                     sys_mmap,
-        [__NR_munmap]                   sys_munmap,
-        [__NR_truncate]                 sys_truncate,
-        [__NR_ftruncate]                sys_ftruncate,
-        [__NR_fchmod]                   sys_fchmod,
-        [__NR_fchown]                   sys_fchown,
-        [__NR_getpriority]              sys_getpriority,
-        [__NR_setpriority]              sys_setpriority,
-        [__NR_profil]                   sys_ni_syscall,
-        [__NR_statfs]                   sys_ni_syscall, /* sys_statfs */
-        [__NR_fstatfs]                  sys_ni_syscall, /* sys_fstatfs */
-        [__NR_ioperm]                   sys_ni_syscall,
-        [__NR_socketcall]               sys_socketcall,
-        [__NR_syslog]                   sys_syslog,
-        [__NR_setitimer]                sys_setitimer,
-        [__NR_getitimer]                sys_getitimer,
-        [__NR_stat]                     sys_newstat,
-        [__NR_lstat]                    sys_newlstat,
-        [__NR_fstat]                    sys_newfstat,
-        [__NR_olduname]                 sys_ni_syscall,
-        [__NR_iopl]                     sys_ni_syscall,
-        [__NR_vhangup]                  sys_vhangup,
-        [__NR_idle]                     sys_ni_syscall,
-        [__NR_vm86]                     sys_ni_syscall,
-        [__NR_wait4]                    sys_wait4,
-        [__NR_swapoff]                  sys_ni_syscall, /* sys_swapoff */
-        [__NR_sysinfo]                  sys_sysinfo,
-        [__NR_ipc]                      sys_ni_syscall, /* sys_ipc */
-        [__NR_fsync]                    sys_fsync,
-        [__NR_sigreturn]                sys_ni_syscall,
-        [__NR_clone]                    sys_ni_syscall, /* ppc_clone */
-        [__NR_setdomainname]            sys_setdomainname,
-        [__NR_uname]                    ppc_newuname,
-        [__NR_modify_ldt]               sys_ni_syscall,
-        [__NR_adjtimex]                 sys_adjtimex,
-        [__NR_mprotect]                 sys_mprotect,
-        [__NR_sigprocmask]              sys_ni_syscall,
-        [__NR_create_module]            sys_ni_syscall,
-        [__NR_init_module]              sys_ni_syscall, /* sys_init_module */
-        [__NR_delete_module]            sys_ni_syscall, /* sys_delete_module */
-        [__NR_get_kernel_syms]          sys_ni_syscall,
-        [__NR_quotactl]                 sys_ni_syscall, /* sys_quotactl */
-        [__NR_getpgid]                  sys_getpgid,
-        [__NR_fchdir]                   sys_fchdir,
-        [__NR_bdflush]                  sys_bdflush,
-        [__NR_sysfs]                    sys_ni_syscall, /* sys_sysfs */
-        [__NR_personality]              ppc64_personality,
-        [__NR_afs_syscall]              sys_ni_syscall,
-        [__NR_setfsuid]                 sys_setfsuid,
-        [__NR_setfsgid]                 sys_setfsgid,
-        [__NR__llseek]                  sys_llseek,
-        [__NR_getdents]                 sys_getdents,
-        [__NR__newselect]               sys_select,
-        [__NR_flock]                    sys_flock,
-        [__NR_msync]                    sys_msync,
-        [__NR_readv]                    sys_readv,
-        [__NR_writev]                   sys_writev,
-        [__NR_getsid]                   sys_getsid,
-        [__NR_fdatasync]                sys_fdatasync,
-        [__NR__sysctl]                  sys_ni_syscall, /* sys_sysctl */
-        [__NR_mlock]                    sys_mlock,
-        [__NR_munlock]                  sys_munlock,
-        [__NR_mlockall]                 sys_mlockall,
-        [__NR_munlockall]               sys_munlockall,
-        [__NR_sched_setparam]           sys_sched_setparam,
-        [__NR_sched_getparam]           sys_sched_getparam,
-        [__NR_sched_setscheduler]       sys_sched_setscheduler,
-        [__NR_sched_getscheduler]       sys_sched_getscheduler,
-        [__NR_sched_yield]              sys_sched_yield,
-        [__NR_sched_get_priority_max]   sys_sched_get_priority_max,
-        [__NR_sched_get_priority_min]   sys_sched_get_priority_min,
-        [__NR_sched_rr_get_interval]    sys_sched_rr_get_interval,
-        [__NR_nanosleep]                sys_nanosleep,
-        [__NR_mremap]                   sys_mremap,
-        [__NR_setresuid]                sys_setresuid,
-        [__NR_getresuid]                sys_getresuid,
-        [__NR_query_module]             sys_ni_syscall,
-        [__NR_poll]                     sys_poll,
-        [__NR_nfsservctl]               sys_ni_syscall, /* sys_nfsservctl */
-        [__NR_setresgid]                sys_setresgid,
-        [__NR_getresgid]                sys_getresgid,
-        [__NR_prctl]                    sys_prctl,
-        [__NR_rt_sigreturn]             sys_ni_syscall, /* ppc64_rt_sigreturn */
-        [__NR_rt_sigaction]             sys_ni_syscall, /* sys_rt_sigaction */
-        [__NR_rt_sigprocmask]           sys_ni_syscall, /* sys_rt_sigprocmask */
-        [__NR_rt_sigpending]            sys_ni_syscall, /* sys_rt_sigpending */
-        [__NR_rt_sigtimedwait]          sys_ni_syscall, /* sys_rt_sigtimedwait */
-        [__NR_rt_sigqueueinfo]          sys_ni_syscall, /* sys_rt_sigqueueinfo */
-        [__NR_rt_sigsuspend]            sys_ni_syscall, /* sys_rt_sigsuspend */
-        [__NR_pread64]                  sys_pread64,
-        [__NR_pwrite64]                 sys_pwrite64,
-        [__NR_chown]                    sys_chown,
-        [__NR_getcwd]                   sys_getcwd,
-        [__NR_capget]                   sys_capget,
-        [__NR_capset]                   sys_capset,
-        [__NR_sigaltstack]              sys_ni_syscall, /* sys_sigaltstack */
-        [__NR_sendfile]                 sys_sendfile64,
-        [__NR_getpmsg]                  sys_ni_syscall,
-        [__NR_putpmsg]                  sys_ni_syscall,
-        [__NR_vfork]                    sys_ni_syscall, /* ppc_vfork */
-        [__NR_ugetrlimit]               sys_getrlimit,
-        [__NR_readahead]                sys_readahead,
-        [192]                           sys_ni_syscall,
-        [193]                           sys_ni_syscall,
-        [194]                           sys_ni_syscall,
-        [195]                           sys_ni_syscall,
-        [196]                           sys_ni_syscall,
-        [197]                           sys_ni_syscall,
-        [__NR_pciconfig_read]           sys_ni_syscall, /* sys_pciconfig_read */
-        [__NR_pciconfig_write]          sys_ni_syscall, /* sys_pciconfig_write */
-        [__NR_pciconfig_iobase]         sys_ni_syscall, /* sys_pciconfig_iobase */
-        [__NR_multiplexer]              sys_ni_syscall,
-        [__NR_getdents64]               sys_getdents64,
-        [__NR_pivot_root]               sys_pivot_root,
-        [204]                           sys_ni_syscall,
-        [__NR_madvise]                  sys_madvise,
-        [__NR_mincore]                  sys_mincore,
-        [__NR_gettid]                   sys_gettid,
-        [__NR_tkill]                    sys_tkill,
-        [__NR_setxattr]                 sys_setxattr,
-        [__NR_lsetxattr]                sys_lsetxattr,
-        [__NR_fsetxattr]                sys_fsetxattr,
-        [__NR_getxattr]                 sys_getxattr,
-        [__NR_lgetxattr]                sys_lgetxattr,
-        [__NR_fgetxattr]                sys_fgetxattr,
-        [__NR_listxattr]                sys_listxattr,
-        [__NR_llistxattr]               sys_llistxattr,
-        [__NR_flistxattr]               sys_flistxattr,
-        [__NR_removexattr]              sys_removexattr,
-        [__NR_lremovexattr]             sys_lremovexattr,
-        [__NR_fremovexattr]             sys_fremovexattr,
-        [__NR_futex]                    sys_futex,
-        [__NR_sched_setaffinity]        sys_sched_setaffinity,
-        [__NR_sched_getaffinity]        sys_sched_getaffinity,
-        [224]                           sys_ni_syscall,
-        [__NR_tuxcall]                  sys_ni_syscall,
-        [226]                           sys_ni_syscall,
-        [__NR_io_setup]                 sys_io_setup,
-        [__NR_io_destroy]               sys_io_destroy,
-        [__NR_io_getevents]             sys_io_getevents,
-        [__NR_io_submit]                sys_io_submit,
-        [__NR_io_cancel]                sys_io_cancel,
-        [__NR_set_tid_address]          sys_ni_syscall, /* sys_set_tid_address */
-        [__NR_fadvise64]                sys_fadvise64,
-        [__NR_exit_group]               sys_ni_syscall, /* sys_exit_group */
-        [__NR_lookup_dcookie]           sys_ni_syscall, /* sys_lookup_dcookie */
-        [__NR_epoll_create]             sys_epoll_create,
-        [__NR_epoll_ctl]                sys_epoll_ctl,
-        [__NR_epoll_wait]               sys_epoll_wait,
-        [__NR_remap_file_pages]         sys_remap_file_pages,
-        [__NR_timer_create]             sys_timer_create,
-        [__NR_timer_settime]            sys_timer_settime,
-        [__NR_timer_gettime]            sys_timer_gettime,
-        [__NR_timer_getoverrun]         sys_timer_getoverrun,
-        [__NR_timer_delete]             sys_timer_delete,
-        [__NR_clock_settime]            sys_clock_settime,
-        [__NR_clock_gettime]            sys_clock_gettime,
-        [__NR_clock_getres]             sys_clock_getres,
-        [__NR_clock_nanosleep]          sys_clock_nanosleep,
-        [__NR_swapcontext]              sys_ni_syscall, /* ppc64_swapcontext */
-        [__NR_tgkill]                   sys_tgkill,
-        [__NR_utimes]                   sys_utimes,
-        [__NR_statfs64]                 sys_statfs64,
-        [__NR_fstatfs64]                sys_fstatfs64,
-        [254]                           sys_ni_syscall,
-        [__NR_rtas]                     ppc_rtas,
-        [256]                           sys_ni_syscall,
-        [257]                           sys_ni_syscall,
-        [258]                           sys_ni_syscall,
-        [__NR_mbind]                    sys_ni_syscall, /* sys_mbind */
-        [__NR_get_mempolicy]            sys_ni_syscall, /* sys_get_mempolicy */
-        [__NR_set_mempolicy]            sys_ni_syscall, /* sys_set_mempolicy */
-        [__NR_mq_open]                  sys_ni_syscall, /* sys_mq_open */
-        [__NR_mq_unlink]                sys_ni_syscall, /* sys_mq_unlink */
-        [__NR_mq_timedsend]             sys_ni_syscall, /* sys_mq_timedsend */
-        [__NR_mq_timedreceive]          sys_ni_syscall, /* sys_mq_timedreceive */
-        [__NR_mq_notify]                sys_ni_syscall, /* sys_mq_notify */
-        [__NR_mq_getsetattr]            sys_ni_syscall, /* sys_mq_getsetattr */
-        [__NR_kexec_load]               sys_ni_syscall, /* sys_kexec_load */
-        [__NR_add_key]                  sys_ni_syscall, /* sys_add_key */
-        [__NR_request_key]              sys_ni_syscall, /* sys_request_key */
-        [__NR_keyctl]                   sys_ni_syscall, /* sys_keyctl */
-        [__NR_waitid]                   sys_ni_syscall, /* sys_waitid */
-        [__NR_ioprio_set]               sys_ni_syscall, /* sys_ioprio_set */
-        [__NR_ioprio_get]               sys_ni_syscall, /* sys_ioprio_get */
-        [__NR_inotify_init]             sys_ni_syscall, /* sys_inotify_init */
-        [__NR_inotify_add_watch]        sys_ni_syscall, /* sys_inotify_add_watch */
-        [__NR_inotify_rm_watch]         sys_ni_syscall, /* sys_inotify_rm_watch */
-        [__NR_spu_run]                  sys_ni_syscall, /* sys_spu_run */
-        [__NR_spu_create]               sys_ni_syscall, /* sys_spu_create */
-        [__NR_pselect6]                 sys_ni_syscall, /* sys_pselect */
-        [__NR_ppoll]                    sys_ni_syscall, /* sys_ppoll */
-        [__NR_unshare]                  sys_unshare,
-        [__NR_splice]                   sys_splice,
-        [__NR_tee]                      sys_tee,
-        [__NR_vmsplice]                 sys_vmsplice,
-        [__NR_openat]                   sys_openat,
-        [__NR_mkdirat]                  sys_mkdirat,
-        [__NR_mknodat]                  sys_mknodat,
-        [__NR_fchownat]                 sys_fchownat,
-        [__NR_futimesat]                sys_futimesat,
-        [__NR_newfstatat]               sys_newfstatat,
-        [__NR_unlinkat]                 sys_unlinkat,
-        [__NR_renameat]                 sys_renameat,
-        [__NR_linkat]                   sys_linkat,
-        [__NR_symlinkat]                sys_symlinkat,
-        [__NR_readlinkat]               sys_readlinkat,
-        [__NR_fchmodat]                 sys_fchmodat,
-        [__NR_faccessat]                sys_faccessat,
-        [__NR_get_robust_list]          sys_get_robust_list,
-        [__NR_set_robust_list]          sys_set_robust_list,
+#define SYSCALL(func)           sys_ni_syscall,
+#define COMPAT_SYS(func)        sys_ni_syscall,
+#define PPC_SYS(func)           sys_ni_syscall,
+#define OLDSYS(func)            sys_ni_syscall,
+#define SYS32ONLY(func)         sys_ni_syscall,
+#define SYSX(f, f3264, f32)     sys_ni_syscall,
+
+#define SYSCALL_SPU(func)       sys_##func,
+#define COMPAT_SYS_SPU(func)    sys_##func,
+#define PPC_SYS_SPU(func)       ppc_##func,
+#define SYSX_SPU(f, f3264, f32) f,
+
+#include <asm/systbl.h>
 };
 
 long spu_sys_callback(struct spu_syscall_block *s)
diff --git a/arch/powerpc/platforms/cell/spu_priv1.c b/arch/powerpc/platforms/cell/spu_priv1.c
deleted file mode 100644
index b2656421c7b5..000000000000
--- a/arch/powerpc/platforms/cell/spu_priv1.c
+++ /dev/null
@@ -1,133 +0,0 @@
-/*
- * access to SPU privileged registers
- */
-#include <linux/module.h>
-
-#include <asm/io.h>
-#include <asm/spu.h>
-
-void spu_int_mask_and(struct spu *spu, int class, u64 mask)
-{
-        u64 old_mask;
-
-        old_mask = in_be64(&spu->priv1->int_mask_RW[class]);
-        out_be64(&spu->priv1->int_mask_RW[class], old_mask & mask);
-}
-EXPORT_SYMBOL_GPL(spu_int_mask_and);
-
-void spu_int_mask_or(struct spu *spu, int class, u64 mask)
-{
-        u64 old_mask;
-
-        old_mask = in_be64(&spu->priv1->int_mask_RW[class]);
-        out_be64(&spu->priv1->int_mask_RW[class], old_mask | mask);
-}
-EXPORT_SYMBOL_GPL(spu_int_mask_or);
-
-void spu_int_mask_set(struct spu *spu, int class, u64 mask)
-{
-        out_be64(&spu->priv1->int_mask_RW[class], mask);
-}
-EXPORT_SYMBOL_GPL(spu_int_mask_set);
-
-u64 spu_int_mask_get(struct spu *spu, int class)
-{
-        return in_be64(&spu->priv1->int_mask_RW[class]);
-}
-EXPORT_SYMBOL_GPL(spu_int_mask_get);
-
-void spu_int_stat_clear(struct spu *spu, int class, u64 stat)
-{
-        out_be64(&spu->priv1->int_stat_RW[class], stat);
-}
-EXPORT_SYMBOL_GPL(spu_int_stat_clear);
-
-u64 spu_int_stat_get(struct spu *spu, int class)
-{
-        return in_be64(&spu->priv1->int_stat_RW[class]);
-}
-EXPORT_SYMBOL_GPL(spu_int_stat_get);
-
-void spu_int_route_set(struct spu *spu, u64 route)
-{
-        out_be64(&spu->priv1->int_route_RW, route);
-}
-EXPORT_SYMBOL_GPL(spu_int_route_set);
-
-u64 spu_mfc_dar_get(struct spu *spu)
-{
-        return in_be64(&spu->priv1->mfc_dar_RW);
-}
-EXPORT_SYMBOL_GPL(spu_mfc_dar_get);
-
-u64 spu_mfc_dsisr_get(struct spu *spu)
-{
-        return in_be64(&spu->priv1->mfc_dsisr_RW);
-}
-EXPORT_SYMBOL_GPL(spu_mfc_dsisr_get);
-
-void spu_mfc_dsisr_set(struct spu *spu, u64 dsisr)
-{
-        out_be64(&spu->priv1->mfc_dsisr_RW, dsisr);
-}
-EXPORT_SYMBOL_GPL(spu_mfc_dsisr_set);
-
-void spu_mfc_sdr_set(struct spu *spu, u64 sdr)
-{
-        out_be64(&spu->priv1->mfc_sdr_RW, sdr);
-}
-EXPORT_SYMBOL_GPL(spu_mfc_sdr_set);
-
-void spu_mfc_sr1_set(struct spu *spu, u64 sr1)
-{
-        out_be64(&spu->priv1->mfc_sr1_RW, sr1);
-}
-EXPORT_SYMBOL_GPL(spu_mfc_sr1_set);
-
-u64 spu_mfc_sr1_get(struct spu *spu)
-{
-        return in_be64(&spu->priv1->mfc_sr1_RW);
-}
-EXPORT_SYMBOL_GPL(spu_mfc_sr1_get);
-
-void spu_mfc_tclass_id_set(struct spu *spu, u64 tclass_id)
-{
-        out_be64(&spu->priv1->mfc_tclass_id_RW, tclass_id);
-}
-EXPORT_SYMBOL_GPL(spu_mfc_tclass_id_set);
-
-u64 spu_mfc_tclass_id_get(struct spu *spu)
-{
-        return in_be64(&spu->priv1->mfc_tclass_id_RW);
-}
-EXPORT_SYMBOL_GPL(spu_mfc_tclass_id_get);
-
-void spu_tlb_invalidate(struct spu *spu)
-{
-        out_be64(&spu->priv1->tlb_invalidate_entry_W, 0ul);
-}
-EXPORT_SYMBOL_GPL(spu_tlb_invalidate);
-
-void spu_resource_allocation_groupID_set(struct spu *spu, u64 id)
-{
-        out_be64(&spu->priv1->resource_allocation_groupID_RW, id);
-}
-EXPORT_SYMBOL_GPL(spu_resource_allocation_groupID_set);
-
-u64 spu_resource_allocation_groupID_get(struct spu *spu)
-{
-        return in_be64(&spu->priv1->resource_allocation_groupID_RW);
-}
-EXPORT_SYMBOL_GPL(spu_resource_allocation_groupID_get);
-
-void spu_resource_allocation_enable_set(struct spu *spu, u64 enable)
-{
-        out_be64(&spu->priv1->resource_allocation_enable_RW, enable);
-}
-EXPORT_SYMBOL_GPL(spu_resource_allocation_enable_set);
-
-u64 spu_resource_allocation_enable_get(struct spu *spu)
-{
-        return in_be64(&spu->priv1->resource_allocation_enable_RW);
-}
-EXPORT_SYMBOL_GPL(spu_resource_allocation_enable_get);
diff --git a/arch/powerpc/platforms/cell/spu_priv1_mmio.c b/arch/powerpc/platforms/cell/spu_priv1_mmio.c
new file mode 100644
index 000000000000..71b69f0a1a48
--- /dev/null
+++ b/arch/powerpc/platforms/cell/spu_priv1_mmio.c
@@ -0,0 +1,159 @@
+/*
+ * spu hypervisor abstraction for direct hardware access.
+ *
+ *  (C) Copyright IBM Deutschland Entwicklung GmbH 2005
+ *  Copyright 2006 Sony Corp.
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; version 2 of the License.
+ *
+ *  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/module.h>
+
+#include <asm/io.h>
+#include <asm/spu.h>
+#include <asm/spu_priv1.h>
+
+#include "interrupt.h"
+
+static void int_mask_and(struct spu *spu, int class, u64 mask)
+{
+        u64 old_mask;
+
+        old_mask = in_be64(&spu->priv1->int_mask_RW[class]);
+        out_be64(&spu->priv1->int_mask_RW[class], old_mask & mask);
+}
+
+static void int_mask_or(struct spu *spu, int class, u64 mask)
+{
+        u64 old_mask;
+
+        old_mask = in_be64(&spu->priv1->int_mask_RW[class]);
+        out_be64(&spu->priv1->int_mask_RW[class], old_mask | mask);
+}
+
+static void int_mask_set(struct spu *spu, int class, u64 mask)
+{
+        out_be64(&spu->priv1->int_mask_RW[class], mask);
+}
+
+static u64 int_mask_get(struct spu *spu, int class)
+{
+        return in_be64(&spu->priv1->int_mask_RW[class]);
+}
+
+static void int_stat_clear(struct spu *spu, int class, u64 stat)
+{
+        out_be64(&spu->priv1->int_stat_RW[class], stat);
+}
+
+static u64 int_stat_get(struct spu *spu, int class)
+{
+        return in_be64(&spu->priv1->int_stat_RW[class]);
+}
+
+static void cpu_affinity_set(struct spu *spu, int cpu)
+{
+        u64 target = iic_get_target_id(cpu);
+        u64 route = target << 48 | target << 32 | target << 16;
+        out_be64(&spu->priv1->int_route_RW, route);
+}
+
+static u64 mfc_dar_get(struct spu *spu)
+{
+        return in_be64(&spu->priv1->mfc_dar_RW);
+}
+
+static u64 mfc_dsisr_get(struct spu *spu)
+{
+        return in_be64(&spu->priv1->mfc_dsisr_RW);
+}
+
+static void mfc_dsisr_set(struct spu *spu, u64 dsisr)
+{
+        out_be64(&spu->priv1->mfc_dsisr_RW, dsisr);
+}
+
+static void mfc_sdr_set(struct spu *spu, u64 sdr)
+{
+        out_be64(&spu->priv1->mfc_sdr_RW, sdr);
+}
+
+static void mfc_sr1_set(struct spu *spu, u64 sr1)
+{
+        out_be64(&spu->priv1->mfc_sr1_RW, sr1);
+}
+
+static u64 mfc_sr1_get(struct spu *spu)
+{
+        return in_be64(&spu->priv1->mfc_sr1_RW);
+}
+
+static void mfc_tclass_id_set(struct spu *spu, u64 tclass_id)
+{
+        out_be64(&spu->priv1->mfc_tclass_id_RW, tclass_id);
+}
+
+static u64 mfc_tclass_id_get(struct spu *spu)
+{
+        return in_be64(&spu->priv1->mfc_tclass_id_RW);
+}
+
+static void tlb_invalidate(struct spu *spu)
+{
+        out_be64(&spu->priv1->tlb_invalidate_entry_W, 0ul);
+}
+
+static void resource_allocation_groupID_set(struct spu *spu, u64 id)
+{
+        out_be64(&spu->priv1->resource_allocation_groupID_RW, id);
+}
+
+static u64 resource_allocation_groupID_get(struct spu *spu)
+{
+        return in_be64(&spu->priv1->resource_allocation_groupID_RW);
+}
+
+static void resource_allocation_enable_set(struct spu *spu, u64 enable)
+{
+        out_be64(&spu->priv1->resource_allocation_enable_RW, enable);
+}
+
+static u64 resource_allocation_enable_get(struct spu *spu)
+{
+        return in_be64(&spu->priv1->resource_allocation_enable_RW);
+}
+
+const struct spu_priv1_ops spu_priv1_mmio_ops =
+{
+        .int_mask_and = int_mask_and,
+        .int_mask_or = int_mask_or,
+        .int_mask_set = int_mask_set,
+        .int_mask_get = int_mask_get,
+        .int_stat_clear = int_stat_clear,
+        .int_stat_get = int_stat_get,
+        .cpu_affinity_set = cpu_affinity_set,
+        .mfc_dar_get = mfc_dar_get,
+        .mfc_dsisr_get = mfc_dsisr_get,
+        .mfc_dsisr_set = mfc_dsisr_set,
+        .mfc_sdr_set = mfc_sdr_set,
+        .mfc_sr1_set = mfc_sr1_set,
+        .mfc_sr1_get = mfc_sr1_get,
+        .mfc_tclass_id_set = mfc_tclass_id_set,
+        .mfc_tclass_id_get = mfc_tclass_id_get,
+        .tlb_invalidate = tlb_invalidate,
+        .resource_allocation_groupID_set = resource_allocation_groupID_set,
+        .resource_allocation_groupID_get = resource_allocation_groupID_get,
+        .resource_allocation_enable_set = resource_allocation_enable_set,
+        .resource_allocation_enable_get = resource_allocation_enable_get,
+};
diff --git a/arch/powerpc/platforms/cell/spufs/Makefile b/arch/powerpc/platforms/cell/spufs/Makefile
index a7cddf40e3d9..bb5dc634272c 100644
--- a/arch/powerpc/platforms/cell/spufs/Makefile
+++ b/arch/powerpc/platforms/cell/spufs/Makefile
@@ -1,5 +1,7 @@
+obj-y += switch.o
+
 obj-$(CONFIG_SPU_FS) += spufs.o
-spufs-y += inode.o file.o context.o switch.o syscalls.o
+spufs-y += inode.o file.o context.o syscalls.o
 spufs-y += sched.o backing_ops.o hw_ops.o run.o
 
 # Rules to build switch.o with the help of SPU tool chain
@@ -8,11 +10,14 @@ SPU_CC		:= $(SPU_CROSS)gcc
 SPU_AS          := $(SPU_CROSS)gcc
 SPU_LD          := $(SPU_CROSS)ld
 SPU_OBJCOPY     := $(SPU_CROSS)objcopy
-SPU_CFLAGS      := -O2 -Wall -I$(srctree)/include -I$(objtree)/include2
-SPU_AFLAGS      := -c -D__ASSEMBLY__ -I$(srctree)/include -I$(objtree)/include2
+SPU_CFLAGS      := -O2 -Wall -I$(srctree)/include \
+                   -I$(objtree)/include2 -D__KERNEL__
+SPU_AFLAGS      := -c -D__ASSEMBLY__ -I$(srctree)/include \
+                   -I$(objtree)/include2 -D__KERNEL__
 SPU_LDFLAGS     := -N -Ttext=0x0
 
 $(obj)/switch.o: $(obj)/spu_save_dump.h $(obj)/spu_restore_dump.h
+clean-files := spu_save_dump.h spu_restore_dump.h
 
 # Compile SPU files
       cmd_spu_cc = $(SPU_CC) $(SPU_CFLAGS) -c -o $@ $<
@@ -45,7 +50,8 @@ cmd_hexdump   = ( \
                 echo " * Hex-dump auto generated from $*.c." ; \
                 echo " * Do not edit!" ; \
                 echo " */" ; \
-                echo "static unsigned int $*_code[] __page_aligned = {" ; \
+                echo "static unsigned int $*_code[] " \
+                        "__attribute__((__aligned__(128))) = {" ; \
                 hexdump -v -e '"0x" 4/1 "%02x" "," "\n"' $< ; \
                 echo "};" ; \
                 ) > $@
diff --git a/arch/powerpc/platforms/cell/spufs/context.c b/arch/powerpc/platforms/cell/spufs/context.c
index 8bb33abfad17..36439c5e9f2d 100644
--- a/arch/powerpc/platforms/cell/spufs/context.c
+++ b/arch/powerpc/platforms/cell/spufs/context.c
@@ -30,7 +30,7 @@
 struct spu_context *alloc_spu_context(void)
 {
         struct spu_context *ctx;
-        ctx = kmalloc(sizeof *ctx, GFP_KERNEL);
+        ctx = kzalloc(sizeof *ctx, GFP_KERNEL);
         if (!ctx)
                 goto out;
         /* Binding to physical processor deferred
@@ -48,17 +48,7 @@ struct spu_context *alloc_spu_context(void)
         init_waitqueue_head(&ctx->wbox_wq);
         init_waitqueue_head(&ctx->stop_wq);
         init_waitqueue_head(&ctx->mfc_wq);
-        ctx->ibox_fasync = NULL;
-        ctx->wbox_fasync = NULL;
-        ctx->mfc_fasync = NULL;
-        ctx->mfc = NULL;
-        ctx->tagwait = 0;
         ctx->state = SPU_STATE_SAVED;
-        ctx->local_store = NULL;
-        ctx->cntl = NULL;
-        ctx->signal1 = NULL;
-        ctx->signal2 = NULL;
-        ctx->spu = NULL;
         ctx->ops = &spu_backing_ops;
         ctx->owner = get_task_mm(current);
         goto out;
diff --git a/arch/powerpc/platforms/cell/spufs/file.c b/arch/powerpc/platforms/cell/spufs/file.c
index 366185e92667..80c02660e617 100644
--- a/arch/powerpc/platforms/cell/spufs/file.c
+++ b/arch/powerpc/platforms/cell/spufs/file.c
@@ -825,6 +825,55 @@ DEFINE_SIMPLE_ATTRIBUTE(spufs_signal2_type, spufs_signal2_type_get,
                                         spufs_signal2_type_set, "%llu");
 
 #ifdef CONFIG_SPUFS_MMAP
+static struct page *spufs_mss_mmap_nopage(struct vm_area_struct *vma,
+                                           unsigned long address, int *type)
+{
+        return spufs_ps_nopage(vma, address, type, 0x0000);
+}
+
+static struct vm_operations_struct spufs_mss_mmap_vmops = {
+        .nopage = spufs_mss_mmap_nopage,
+};
+
+/*
+ * mmap support for problem state MFC DMA area [0x0000 - 0x0fff].
+ * Mapping this area requires that the application have CAP_SYS_RAWIO,
+ * as these registers require special care when read/writing.
+ */
+static int spufs_mss_mmap(struct file *file, struct vm_area_struct *vma)
+{
+        if (!(vma->vm_flags & VM_SHARED))
+                return -EINVAL;
+
+        if (!capable(CAP_SYS_RAWIO))
+                return -EPERM;
+
+        vma->vm_flags |= VM_RESERVED;
+        vma->vm_page_prot = __pgprot(pgprot_val(vma->vm_page_prot)
+                                     | _PAGE_NO_CACHE);
+
+        vma->vm_ops = &spufs_mss_mmap_vmops;
+        return 0;
+}
+#endif
+
+static int spufs_mss_open(struct inode *inode, struct file *file)
+{
+        struct spufs_inode_info *i = SPUFS_I(inode);
+
+        file->private_data = i->i_ctx;
+        return nonseekable_open(inode, file);
+}
+
+static struct file_operations spufs_mss_fops = {
+        .open    = spufs_mss_open,
+#ifdef CONFIG_SPUFS_MMAP
+        .mmap    = spufs_mss_mmap,
+#endif
+};
+
+
+#ifdef CONFIG_SPUFS_MMAP
 static struct page *spufs_mfc_mmap_nopage(struct vm_area_struct *vma,
                                            unsigned long address, int *type)
 {
@@ -1279,6 +1328,22 @@ static u64 spufs_srr0_get(void *data)
 DEFINE_SIMPLE_ATTRIBUTE(spufs_srr0_ops, spufs_srr0_get, spufs_srr0_set,
                         "%llx\n")
 
+static u64 spufs_id_get(void *data)
+{
+        struct spu_context *ctx = data;
+        u64 num;
+
+        spu_acquire(ctx);
+        if (ctx->state == SPU_STATE_RUNNABLE)
+                num = ctx->spu->number;
+        else
+                num = (unsigned int)-1;
+        spu_release(ctx);
+
+        return num;
+}
+DEFINE_SIMPLE_ATTRIBUTE(spufs_id_ops, spufs_id_get, 0, "0x%llx\n")
+
 struct tree_descr spufs_dir_contents[] = {
         { "mem",  &spufs_mem_fops,  0666, },
         { "regs", &spufs_regs_fops,  0666, },
@@ -1292,6 +1357,7 @@ struct tree_descr spufs_dir_contents[] = {
         { "signal2", &spufs_signal2_fops, 0666, },
         { "signal1_type", &spufs_signal1_type, 0666, },
         { "signal2_type", &spufs_signal2_type, 0666, },
+        { "mss", &spufs_mss_fops, 0666, },
         { "mfc", &spufs_mfc_fops, 0666, },
         { "cntl", &spufs_cntl_fops,  0666, },
         { "npc", &spufs_npc_ops, 0666, },
@@ -1301,5 +1367,6 @@ struct tree_descr spufs_dir_contents[] = {
         { "spu_tag_mask", &spufs_spu_tag_mask_ops, 0666, },
         { "event_mask", &spufs_event_mask_ops, 0666, },
         { "srr0", &spufs_srr0_ops, 0666, },
+        { "phys-id", &spufs_id_ops, 0666, },
         {},
 };
diff --git a/arch/powerpc/platforms/cell/spufs/hw_ops.c b/arch/powerpc/platforms/cell/spufs/hw_ops.c
index a13a8b5a014d..ede2cac46b6d 100644
--- a/arch/powerpc/platforms/cell/spufs/hw_ops.c
+++ b/arch/powerpc/platforms/cell/spufs/hw_ops.c
@@ -32,6 +32,7 @@
 
 #include <asm/io.h>
 #include <asm/spu.h>
+#include <asm/spu_priv1.h>
 #include <asm/spu_csa.h>
 #include <asm/mmu_context.h>
 #include "spufs.h"
diff --git a/arch/powerpc/platforms/cell/spufs/inode.c b/arch/powerpc/platforms/cell/spufs/inode.c
index d9554199afa7..7b4572805db9 100644
--- a/arch/powerpc/platforms/cell/spufs/inode.c
+++ b/arch/powerpc/platforms/cell/spufs/inode.c
@@ -157,20 +157,12 @@ static void spufs_prune_dir(struct dentry *dir)
         mutex_unlock(&dir->d_inode->i_mutex);
 }
 
+/* Caller must hold root->i_mutex */
 static int spufs_rmdir(struct inode *root, struct dentry *dir_dentry)
 {
-        struct spu_context *ctx;
-
         /* remove all entries */
-        mutex_lock(&root->i_mutex);
         spufs_prune_dir(dir_dentry);
-        mutex_unlock(&root->i_mutex);
-
-        /* We have to give up the mm_struct */
-        ctx = SPUFS_I(dir_dentry->d_inode)->i_ctx;
-        spu_forget(ctx);
 
-        /* XXX Do we need to hold i_mutex here ? */
         return simple_rmdir(root, dir_dentry);
 }
 
@@ -199,16 +191,23 @@ out:
 
 static int spufs_dir_close(struct inode *inode, struct file *file)
 {
+        struct spu_context *ctx;
         struct inode *dir;
         struct dentry *dentry;
         int ret;
 
         dentry = file->f_dentry;
         dir = dentry->d_parent->d_inode;
+        ctx = SPUFS_I(dentry->d_inode)->i_ctx;
 
+        mutex_lock(&dir->i_mutex);
         ret = spufs_rmdir(dir, dentry);
+        mutex_unlock(&dir->i_mutex);
         WARN_ON(ret);
 
+        /* We have to give up the mm_struct */
+        spu_forget(ctx);
+
         return dcache_dir_close(inode, file);
 }
 
@@ -305,6 +304,10 @@ long spufs_create_thread(struct nameidata *nd,
             nd->dentry != nd->dentry->d_sb->s_root)
                 goto out;
 
+        /* all flags are reserved */
+        if (flags)
+                goto out;
+
         dentry = lookup_create(nd, 1);
         ret = PTR_ERR(dentry);
         if (IS_ERR(dentry))
@@ -324,8 +327,13 @@ long spufs_create_thread(struct nameidata *nd,
          * in error path of *_open().
          */
         ret = spufs_context_open(dget(dentry), mntget(nd->mnt));
-        if (ret < 0)
-                spufs_rmdir(nd->dentry->d_inode, dentry);
+        if (ret < 0) {
+                WARN_ON(spufs_rmdir(nd->dentry->d_inode, dentry));
+                mutex_unlock(&nd->dentry->d_inode->i_mutex);
+                spu_forget(SPUFS_I(dentry->d_inode)->i_ctx);
+                dput(dentry);
+                goto out;
+        }
 
 out_dput:
         dput(dentry);
@@ -428,11 +436,11 @@ spufs_fill_super(struct super_block *sb, void *data, int silent)
         return spufs_create_root(sb, data);
 }
 
-static struct super_block *
+static int
 spufs_get_sb(struct file_system_type *fstype, int flags,
-                const char *name, void *data)
+                const char *name, void *data, struct vfsmount *mnt)
 {
-        return get_sb_single(fstype, flags, data, spufs_fill_super);
+        return get_sb_single(fstype, flags, data, spufs_fill_super, mnt);
 }
 
 static struct file_system_type spufs_type = {
diff --git a/arch/powerpc/platforms/cell/spufs/sched.c b/arch/powerpc/platforms/cell/spufs/sched.c
index bf652cd77000..3dcc5d8d66b9 100644
--- a/arch/powerpc/platforms/cell/spufs/sched.c
+++ b/arch/powerpc/platforms/cell/spufs/sched.c
@@ -43,6 +43,7 @@
 #include <asm/mmu_context.h>
 #include <asm/spu.h>
 #include <asm/spu_csa.h>
+#include <asm/spu_priv1.h>
 #include "spufs.h"
 
 #define SPU_MIN_TIMESLICE       (100 * HZ / 1000)
@@ -363,7 +364,7 @@ int spu_activate(struct spu_context *ctx, u64 flags)
          * We're likely to wait for interrupts on the same
          * CPU that we are now on, so send them here.
          */
-        spu_irq_setaffinity(spu, raw_smp_processor_id());
+        spu_cpu_affinity_set(spu, raw_smp_processor_id());
         put_active_spu(spu);
         return 0;
 }
diff --git a/arch/powerpc/platforms/cell/spufs/spu_restore_dump.h_shipped b/arch/powerpc/platforms/cell/spufs/spu_restore_dump.h_shipped
index 1b2355ff7036..15183d209b58 100644
--- a/arch/powerpc/platforms/cell/spufs/spu_restore_dump.h_shipped
+++ b/arch/powerpc/platforms/cell/spufs/spu_restore_dump.h_shipped
@@ -3,229 +3,901 @@
  * Hex-dump auto generated from spu_restore.c.
  * Do not edit!
  */
-static unsigned int spu_restore_code[] __page_aligned = {
-0x40800000, 0x409ff801, 0x24000080, 0x24fd8081,
-0x1cd80081, 0x33001180, 0x42030003, 0x33800284,
-0x1c010204, 0x40200000, 0x40200000, 0x40200000,
-0x34000190, 0x34004191, 0x34008192, 0x3400c193,
-0x141fc205, 0x23fffd84, 0x1c100183, 0x217ffa85,
-0x3080a000, 0x3080a201, 0x3080a402, 0x3080a603,
-0x3080a804, 0x3080aa05, 0x3080ac06, 0x3080ae07,
-0x3080b008, 0x3080b209, 0x3080b40a, 0x3080b60b,
-0x3080b80c, 0x3080ba0d, 0x3080bc0e, 0x3080be0f,
-0x00003ffc, 0x00000000, 0x00000000, 0x00000000,
-0x01a00182, 0x3ec00083, 0xb0a14103, 0x01a00204,
-0x3ec10082, 0x4202800e, 0x04000703, 0xb0a14202,
-0x21a00803, 0x3fbf028d, 0x3f20068d, 0x3fbe0682,
-0x3fe30102, 0x21a00882, 0x3f82028f, 0x3fe3078f,
-0x3fbf0784, 0x3f200204, 0x3fbe0204, 0x3fe30204,
-0x04000203, 0x21a00903, 0x40848002, 0x21a00982,
-0x40800003, 0x21a00a03, 0x40802002, 0x21a00a82,
-0x21a00083, 0x40800082, 0x21a00b02, 0x10002818,
-0x40a80002, 0x32800007, 0x4207000c, 0x18008208,
-0x40a0000b, 0x4080020a, 0x40800709, 0x00200000,
-0x42070002, 0x3ac30384, 0x1cffc489, 0x00200000,
-0x18008383, 0x38830382, 0x4cffc486, 0x3ac28185,
-0xb0408584, 0x28830382, 0x1c020387, 0x38828182,
-0xb0408405, 0x1802c408, 0x28828182, 0x217ff886,
-0x04000583, 0x21a00803, 0x3fbe0682, 0x3fe30102,
-0x04000106, 0x21a00886, 0x04000603, 0x21a00903,
-0x40803c02, 0x21a00982, 0x40800003, 0x04000184,
-0x21a00a04, 0x40802202, 0x21a00a82, 0x42028005,
-0x34208702, 0x21002282, 0x21a00804, 0x21a00886,
-0x3fbf0782, 0x3f200102, 0x3fbe0102, 0x3fe30102,
-0x21a00902, 0x40804003, 0x21a00983, 0x21a00a04,
-0x40805a02, 0x21a00a82, 0x40800083, 0x21a00b83,
-0x01a00c02, 0x01a00d83, 0x3420c282, 0x21a00e02,
-0x34210283, 0x21a00f03, 0x34200284, 0x77400200,
-0x3421c282, 0x21a00702, 0x34218283, 0x21a00083,
-0x34214282, 0x21a00b02, 0x4200480c, 0x00200000,
-0x1c010286, 0x34220284, 0x34220302, 0x0f608203,
-0x5c024204, 0x3b81810b, 0x42013c02, 0x00200000,
-0x18008185, 0x38808183, 0x3b814182, 0x21004e84,
-0x4020007f, 0x35000100, 0x000004e0, 0x000002a0,
-0x000002e8, 0x00000428, 0x00000360, 0x000002e8,
-0x000004a0, 0x00000468, 0x000003c8, 0x00000360,
-0x409ffe02, 0x30801203, 0x40800204, 0x3ec40085,
-0x10009c09, 0x3ac10606, 0xb060c105, 0x4020007f,
-0x4020007f, 0x20801203, 0x38810602, 0xb0408586,
-0x28810602, 0x32004180, 0x34204702, 0x21a00382,
-0x4020007f, 0x327fdc80, 0x409ffe02, 0x30801203,
-0x40800204, 0x3ec40087, 0x40800405, 0x00200000,
-0x40800606, 0x3ac10608, 0x3ac14609, 0x3ac1860a,
-0xb060c107, 0x20801203, 0x41004003, 0x38810602,
-0x4020007f, 0xb0408188, 0x4020007f, 0x28810602,
-0x41201002, 0x38814603, 0x10009c09, 0xb060c109,
-0x4020007f, 0x28814603, 0x41193f83, 0x38818602,
-0x60ffc003, 0xb040818a, 0x28818602, 0x32003080,
-0x409ffe02, 0x30801203, 0x40800204, 0x3ec40087,
-0x41201008, 0x10009c14, 0x40800405, 0x3ac10609,
-0x40800606, 0x3ac1460a, 0xb060c107, 0x3ac1860b,
-0x20801203, 0x38810602, 0xb0408409, 0x28810602,
-0x38814603, 0xb060c40a, 0x4020007f, 0x28814603,
-0x41193f83, 0x38818602, 0x60ffc003, 0xb040818b,
-0x28818602, 0x32002380, 0x409ffe02, 0x30801204,
-0x40800205, 0x3ec40083, 0x40800406, 0x3ac14607,
-0x3ac18608, 0xb0810103, 0x41004002, 0x20801204,
-0x4020007f, 0x38814603, 0x10009c0b, 0xb060c107,
-0x4020007f, 0x4020007f, 0x28814603, 0x38818602,
-0x4020007f, 0x4020007f, 0xb0408588, 0x28818602,
-0x4020007f, 0x32001780, 0x409ffe02, 0x1000640e,
-0x40800204, 0x30801203, 0x40800405, 0x3ec40087,
-0x40800606, 0x3ac10608, 0x3ac14609, 0x3ac1860a,
-0xb060c107, 0x20801203, 0x413d8003, 0x38810602,
-0x4020007f, 0x327fd780, 0x409ffe02, 0x10007f0c,
-0x40800205, 0x30801204, 0x40800406, 0x3ec40083,
-0x3ac14607, 0x3ac18608, 0xb0810103, 0x413d8002,
-0x20801204, 0x38814603, 0x4020007f, 0x327feb80,
-0x409ffe02, 0x30801203, 0x40800204, 0x3ec40087,
-0x40800405, 0x1000650a, 0x40800606, 0x3ac10608,
-0x3ac14609, 0x3ac1860a, 0xb060c107, 0x20801203,
-0x38810602, 0xb0408588, 0x4020007f, 0x327fc980,
-0x00400000, 0x40800003, 0x4020007f, 0x35000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
+static unsigned int spu_restore_code[]  __attribute__((__aligned__(128))) = {
+0x40800000,
+0x409ff801,
+0x24000080,
+0x24fd8081,
+0x1cd80081,
+0x33001180,
+0x42030003,
+0x33800284,
+0x1c010204,
+0x40200000,
+0x40200000,
+0x40200000,
+0x34000190,
+0x34004191,
+0x34008192,
+0x3400c193,
+0x141fc205,
+0x23fffd84,
+0x1c100183,
+0x217ffa85,
+0x3080a000,
+0x3080a201,
+0x3080a402,
+0x3080a603,
+0x3080a804,
+0x3080aa05,
+0x3080ac06,
+0x3080ae07,
+0x3080b008,
+0x3080b209,
+0x3080b40a,
+0x3080b60b,
+0x3080b80c,
+0x3080ba0d,
+0x3080bc0e,
+0x3080be0f,
+0x00003ffc,
+0x00000000,
+0x00000000,
+0x00000000,
+0x01a00182,
+0x3ec00083,
+0xb0a14103,
+0x01a00204,
+0x3ec10082,
+0x4202800e,
+0x04000703,
+0xb0a14202,
+0x21a00803,
+0x3fbf028d,
+0x3f20068d,
+0x3fbe0682,
+0x3fe30102,
+0x21a00882,
+0x3f82028f,
+0x3fe3078f,
+0x3fbf0784,
+0x3f200204,
+0x3fbe0204,
+0x3fe30204,
+0x04000203,
+0x21a00903,
+0x40848002,
+0x21a00982,
+0x40800003,
+0x21a00a03,
+0x40802002,
+0x21a00a82,
+0x21a00083,
+0x40800082,
+0x21a00b02,
+0x10002818,
+0x42a00002,
+0x32800007,
+0x4207000c,
+0x18008208,
+0x40a0000b,
+0x4080020a,
+0x40800709,
+0x00200000,
+0x42070002,
+0x3ac30384,
+0x1cffc489,
+0x00200000,
+0x18008383,
+0x38830382,
+0x4cffc486,
+0x3ac28185,
+0xb0408584,
+0x28830382,
+0x1c020387,
+0x38828182,
+0xb0408405,
+0x1802c408,
+0x28828182,
+0x217ff886,
+0x04000583,
+0x21a00803,
+0x3fbe0682,
+0x3fe30102,
+0x04000106,
+0x21a00886,
+0x04000603,
+0x21a00903,
+0x40803c02,
+0x21a00982,
+0x40800003,
+0x04000184,
+0x21a00a04,
+0x40802202,
+0x21a00a82,
+0x42028005,
+0x34208702,
+0x21002282,
+0x21a00804,
+0x21a00886,
+0x3fbf0782,
+0x3f200102,
+0x3fbe0102,
+0x3fe30102,
+0x21a00902,
+0x40804003,
+0x21a00983,
+0x21a00a04,
+0x40805a02,
+0x21a00a82,
+0x40800083,
+0x21a00b83,
+0x01a00c02,
+0x01a00d83,
+0x3420c282,
+0x21a00e02,
+0x34210283,
+0x21a00f03,
+0x34200284,
+0x77400200,
+0x3421c282,
+0x21a00702,
+0x34218283,
+0x21a00083,
+0x34214282,
+0x21a00b02,
+0x4200480c,
+0x00200000,
+0x1c010286,
+0x34220284,
+0x34220302,
+0x0f608203,
+0x5c024204,
+0x3b81810b,
+0x42013c02,
+0x00200000,
+0x18008185,
+0x38808183,
+0x3b814182,
+0x21004e84,
+0x4020007f,
+0x35000100,
+0x000004e0,
+0x000002a0,
+0x000002e8,
+0x00000428,
+0x00000360,
+0x000002e8,
+0x000004a0,
+0x00000468,
+0x000003c8,
+0x00000360,
+0x409ffe02,
+0x30801203,
+0x40800204,
+0x3ec40085,
+0x10009c09,
+0x3ac10606,
+0xb060c105,
+0x4020007f,
+0x4020007f,
+0x20801203,
+0x38810602,
+0xb0408586,
+0x28810602,
+0x32004180,
+0x34204702,
+0x21a00382,
+0x4020007f,
+0x327fdc80,
+0x409ffe02,
+0x30801203,
+0x40800204,
+0x3ec40087,
+0x40800405,
+0x00200000,
+0x40800606,
+0x3ac10608,
+0x3ac14609,
+0x3ac1860a,
+0xb060c107,
+0x20801203,
+0x41004003,
+0x38810602,
+0x4020007f,
+0xb0408188,
+0x4020007f,
+0x28810602,
+0x41201002,
+0x38814603,
+0x10009c09,
+0xb060c109,
+0x4020007f,
+0x28814603,
+0x41193f83,
+0x38818602,
+0x60ffc003,
+0xb040818a,
+0x28818602,
+0x32003080,
+0x409ffe02,
+0x30801203,
+0x40800204,
+0x3ec40087,
+0x41201008,
+0x10009c14,
+0x40800405,
+0x3ac10609,
+0x40800606,
+0x3ac1460a,
+0xb060c107,
+0x3ac1860b,
+0x20801203,
+0x38810602,
+0xb0408409,
+0x28810602,
+0x38814603,
+0xb060c40a,
+0x4020007f,
+0x28814603,
+0x41193f83,
+0x38818602,
+0x60ffc003,
+0xb040818b,
+0x28818602,
+0x32002380,
+0x409ffe02,
+0x30801204,
+0x40800205,
+0x3ec40083,
+0x40800406,
+0x3ac14607,
+0x3ac18608,
+0xb0810103,
+0x41004002,
+0x20801204,
+0x4020007f,
+0x38814603,
+0x10009c0b,
+0xb060c107,
+0x4020007f,
+0x4020007f,
+0x28814603,
+0x38818602,
+0x4020007f,
+0x4020007f,
+0xb0408588,
+0x28818602,
+0x4020007f,
+0x32001780,
+0x409ffe02,
+0x1000640e,
+0x40800204,
+0x30801203,
+0x40800405,
+0x3ec40087,
+0x40800606,
+0x3ac10608,
+0x3ac14609,
+0x3ac1860a,
+0xb060c107,
+0x20801203,
+0x413d8003,
+0x38810602,
+0x4020007f,
+0x327fd780,
+0x409ffe02,
+0x10007f0c,
+0x40800205,
+0x30801204,
+0x40800406,
+0x3ec40083,
+0x3ac14607,
+0x3ac18608,
+0xb0810103,
+0x413d8002,
+0x20801204,
+0x38814603,
+0x4020007f,
+0x327feb80,
+0x409ffe02,
+0x30801203,
+0x40800204,
+0x3ec40087,
+0x40800405,
+0x1000650a,
+0x40800606,
+0x3ac10608,
+0x3ac14609,
+0x3ac1860a,
+0xb060c107,
+0x20801203,
+0x38810602,
+0xb0408588,
+0x4020007f,
+0x327fc980,
+0x00400000,
+0x40800003,
+0x4020007f,
+0x35000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
 };
diff --git a/arch/powerpc/platforms/cell/spufs/spu_save_dump.h_shipped b/arch/powerpc/platforms/cell/spufs/spu_save_dump.h_shipped
index 39e54003f1df..b9f81ac8a632 100644
--- a/arch/powerpc/platforms/cell/spufs/spu_save_dump.h_shipped
+++ b/arch/powerpc/platforms/cell/spufs/spu_save_dump.h_shipped
@@ -3,189 +3,741 @@
  * Hex-dump auto generated from spu_save.c.
  * Do not edit!
  */
-static unsigned int spu_save_code[] __page_aligned = {
-0x20805000, 0x20805201, 0x20805402, 0x20805603,
-0x20805804, 0x20805a05, 0x20805c06, 0x20805e07,
-0x20806008, 0x20806209, 0x2080640a, 0x2080660b,
-0x2080680c, 0x20806a0d, 0x20806c0e, 0x20806e0f,
-0x4201c003, 0x33800184, 0x1c010204, 0x40200000,
-0x24000190, 0x24004191, 0x24008192, 0x2400c193,
-0x141fc205, 0x23fffd84, 0x1c100183, 0x217ffb85,
-0x40800000, 0x409ff801, 0x24000080, 0x24fd8081,
-0x1cd80081, 0x33000180, 0x00000000, 0x00000000,
-0x01a00182, 0x3ec00083, 0xb1c38103, 0x01a00204,
-0x3ec10082, 0x4201400d, 0xb1c38202, 0x01a00583,
-0x34218682, 0x3ed80684, 0xb0408184, 0x24218682,
-0x01a00603, 0x00200000, 0x34214682, 0x3ed40684,
-0xb0408184, 0x40800003, 0x24214682, 0x21a00083,
-0x40800082, 0x21a00b02, 0x4020007f, 0x1000251e,
-0x40a80002, 0x32800008, 0x4205c00c, 0x00200000,
-0x40a0000b, 0x3f82070f, 0x4080020a, 0x40800709,
-0x3fe3078f, 0x3fbf0783, 0x3f200183, 0x3fbe0183,
-0x3fe30187, 0x18008387, 0x4205c002, 0x3ac30404,
-0x1cffc489, 0x00200000, 0x18008403, 0x38830402,
-0x4cffc486, 0x3ac28185, 0xb0408584, 0x28830402,
-0x1c020408, 0x38828182, 0xb0408385, 0x1802c387,
-0x28828182, 0x217ff886, 0x04000582, 0x32800007,
-0x21a00802, 0x3fbf0705, 0x3f200285, 0x3fbe0285,
-0x3fe30285, 0x21a00885, 0x04000603, 0x21a00903,
-0x40803c02, 0x21a00982, 0x04000386, 0x21a00a06,
-0x40801202, 0x21a00a82, 0x73000003, 0x24200683,
-0x01a00404, 0x00200000, 0x34204682, 0x3ec40683,
-0xb0408203, 0x24204682, 0x01a00783, 0x00200000,
-0x3421c682, 0x3edc0684, 0xb0408184, 0x2421c682,
-0x21a00806, 0x21a00885, 0x3fbf0784, 0x3f200204,
-0x3fbe0204, 0x3fe30204, 0x21a00904, 0x40804002,
-0x21a00982, 0x21a00a06, 0x40805a02, 0x21a00a82,
-0x04000683, 0x21a00803, 0x21a00885, 0x21a00904,
-0x40848002, 0x21a00982, 0x21a00a06, 0x40801002,
-0x21a00a82, 0x21a00a06, 0x40806602, 0x00200000,
-0x35800009, 0x21a00a82, 0x40800083, 0x21a00b83,
-0x01a00c02, 0x01a00d83, 0x00003ffb, 0x40800003,
-0x4020007f, 0x35000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
+static unsigned int spu_save_code[]  __attribute__((__aligned__(128))) = {
+0x20805000,
+0x20805201,
+0x20805402,
+0x20805603,
+0x20805804,
+0x20805a05,
+0x20805c06,
+0x20805e07,
+0x20806008,
+0x20806209,
+0x2080640a,
+0x2080660b,
+0x2080680c,
+0x20806a0d,
+0x20806c0e,
+0x20806e0f,
+0x4201c003,
+0x33800184,
+0x1c010204,
+0x40200000,
+0x24000190,
+0x24004191,
+0x24008192,
+0x2400c193,
+0x141fc205,
+0x23fffd84,
+0x1c100183,
+0x217ffb85,
+0x40800000,
+0x409ff801,
+0x24000080,
+0x24fd8081,
+0x1cd80081,
+0x33000180,
+0x00000000,
+0x00000000,
+0x01a00182,
+0x3ec00083,
+0xb1c38103,
+0x01a00204,
+0x3ec10082,
+0x4201400d,
+0xb1c38202,
+0x01a00583,
+0x34218682,
+0x3ed80684,
+0xb0408184,
+0x24218682,
+0x01a00603,
+0x00200000,
+0x34214682,
+0x3ed40684,
+0xb0408184,
+0x40800003,
+0x24214682,
+0x21a00083,
+0x40800082,
+0x21a00b02,
+0x4020007f,
+0x1000251e,
+0x42a00002,
+0x32800008,
+0x4205c00c,
+0x00200000,
+0x40a0000b,
+0x3f82070f,
+0x4080020a,
+0x40800709,
+0x3fe3078f,
+0x3fbf0783,
+0x3f200183,
+0x3fbe0183,
+0x3fe30187,
+0x18008387,
+0x4205c002,
+0x3ac30404,
+0x1cffc489,
+0x00200000,
+0x18008403,
+0x38830402,
+0x4cffc486,
+0x3ac28185,
+0xb0408584,
+0x28830402,
+0x1c020408,
+0x38828182,
+0xb0408385,
+0x1802c387,
+0x28828182,
+0x217ff886,
+0x04000582,
+0x32800007,
+0x21a00802,
+0x3fbf0705,
+0x3f200285,
+0x3fbe0285,
+0x3fe30285,
+0x21a00885,
+0x04000603,
+0x21a00903,
+0x40803c02,
+0x21a00982,
+0x04000386,
+0x21a00a06,
+0x40801202,
+0x21a00a82,
+0x73000003,
+0x24200683,
+0x01a00404,
+0x00200000,
+0x34204682,
+0x3ec40683,
+0xb0408203,
+0x24204682,
+0x01a00783,
+0x00200000,
+0x3421c682,
+0x3edc0684,
+0xb0408184,
+0x2421c682,
+0x21a00806,
+0x21a00885,
+0x3fbf0784,
+0x3f200204,
+0x3fbe0204,
+0x3fe30204,
+0x21a00904,
+0x40804002,
+0x21a00982,
+0x21a00a06,
+0x40805a02,
+0x21a00a82,
+0x04000683,
+0x21a00803,
+0x21a00885,
+0x21a00904,
+0x40848002,
+0x21a00982,
+0x21a00a06,
+0x40801002,
+0x21a00a82,
+0x21a00a06,
+0x40806602,
+0x00200000,
+0x35800009,
+0x21a00a82,
+0x40800083,
+0x21a00b83,
+0x01a00c02,
+0x01a00d83,
+0x00003ffb,
+0x40800003,
+0x4020007f,
+0x35000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
+0x00000000,
 };
diff --git a/arch/powerpc/platforms/cell/spufs/switch.c b/arch/powerpc/platforms/cell/spufs/switch.c
index 1726bfe38ee0..b30e55dab832 100644
--- a/arch/powerpc/platforms/cell/spufs/switch.c
+++ b/arch/powerpc/platforms/cell/spufs/switch.c
@@ -46,6 +46,7 @@
 
 #include <asm/io.h>
 #include <asm/spu.h>
+#include <asm/spu_priv1.h>
 #include <asm/spu_csa.h>
 #include <asm/mmu_context.h>
 
@@ -622,12 +623,17 @@ static inline void save_ppuint_mb(struct spu_state *csa, struct spu *spu)
 static inline void save_ch_part1(struct spu_state *csa, struct spu *spu)
 {
         struct spu_priv2 __iomem *priv2 = spu->priv2;
-        u64 idx, ch_indices[7] = { 0UL, 1UL, 3UL, 4UL, 24UL, 25UL, 27UL };
+        u64 idx, ch_indices[7] = { 0UL, 3UL, 4UL, 24UL, 25UL, 27UL };
         int i;
 
         /* Save, Step 42:
-         *     Save the following CH: [0,1,3,4,24,25,27]
          */
+
+        /* Save CH 1, without channel count */
+        out_be64(&priv2->spu_chnlcntptr_RW, 1);
+        csa->spu_chnldata_RW[1] = in_be64(&priv2->spu_chnldata_RW);
+
+        /* Save the following CH: [0,3,4,24,25,27] */
         for (i = 0; i < 7; i++) {
                 idx = ch_indices[i];
                 out_be64(&priv2->spu_chnlcntptr_RW, idx);
@@ -718,13 +724,15 @@ static inline void invalidate_slbs(struct spu_state *csa, struct spu *spu)
 
 static inline void get_kernel_slb(u64 ea, u64 slb[2])
 {
-        slb[0] = (get_kernel_vsid(ea) << SLB_VSID_SHIFT) | SLB_VSID_KERNEL;
-        slb[1] = (ea & ESID_MASK) | SLB_ESID_V;
+        u64 llp;
 
-        /* Large pages are used for kernel text/data, but not vmalloc.  */
-        if (cpu_has_feature(CPU_FTR_16M_PAGE)
-            && REGION_ID(ea) == KERNEL_REGION_ID)
-                slb[0] |= SLB_VSID_L;
+        if (REGION_ID(ea) == KERNEL_REGION_ID)
+                llp = mmu_psize_defs[mmu_linear_psize].sllp;
+        else
+                llp = mmu_psize_defs[mmu_virtual_psize].sllp;
+        slb[0] = (get_kernel_vsid(ea) << SLB_VSID_SHIFT) |
+                SLB_VSID_KERNEL | llp;
+        slb[1] = (ea & ESID_MASK) | SLB_ESID_V;
 }
 
 static inline void load_mfc_slb(struct spu *spu, u64 slb[2], int slbe)
@@ -1103,13 +1111,18 @@ static inline void clear_spu_status(struct spu_state *csa, struct spu *spu)
 static inline void reset_ch_part1(struct spu_state *csa, struct spu *spu)
 {
         struct spu_priv2 __iomem *priv2 = spu->priv2;
-        u64 ch_indices[7] = { 0UL, 1UL, 3UL, 4UL, 24UL, 25UL, 27UL };
+        u64 ch_indices[7] = { 0UL, 3UL, 4UL, 24UL, 25UL, 27UL };
         u64 idx;
         int i;
 
         /* Restore, Step 20:
-         *     Reset the following CH: [0,1,3,4,24,25,27]
          */
+
+        /* Reset CH 1 */
+        out_be64(&priv2->spu_chnlcntptr_RW, 1);
+        out_be64(&priv2->spu_chnldata_RW, 0UL);
+
+        /* Reset the following CH: [0,3,4,24,25,27] */
         for (i = 0; i < 7; i++) {
                 idx = ch_indices[i];
                 out_be64(&priv2->spu_chnlcntptr_RW, idx);
@@ -1570,12 +1583,17 @@ static inline void restore_decr_wrapped(struct spu_state *csa, struct spu *spu)
 static inline void restore_ch_part1(struct spu_state *csa, struct spu *spu)
 {
         struct spu_priv2 __iomem *priv2 = spu->priv2;
-        u64 idx, ch_indices[7] = { 0UL, 1UL, 3UL, 4UL, 24UL, 25UL, 27UL };
+        u64 idx, ch_indices[7] = { 0UL, 3UL, 4UL, 24UL, 25UL, 27UL };
         int i;
 
         /* Restore, Step 59:
-         *     Restore the following CH: [0,1,3,4,24,25,27]
          */
+
+        /* Restore CH 1 without count */
+        out_be64(&priv2->spu_chnlcntptr_RW, 1);
+        out_be64(&priv2->spu_chnldata_RW, csa->spu_chnldata_RW[1]);
+
+        /* Restore the following CH: [0,3,4,24,25,27] */
         for (i = 0; i < 7; i++) {
                 idx = ch_indices[i];
                 out_be64(&priv2->spu_chnlcntptr_RW, idx);
@@ -2074,6 +2092,7 @@ int spu_save(struct spu_state *prev, struct spu *spu)
         }
         return rc;
 }
+EXPORT_SYMBOL_GPL(spu_save);
 
 /**
  * spu_restore - SPU context restore, with harvest and locking.
@@ -2090,7 +2109,6 @@ int spu_restore(struct spu_state *new, struct spu *spu)
 
         acquire_spu_lock(spu);
         harvest(NULL, spu);
-        spu->stop_code = 0;
         spu->dar = 0;
         spu->dsisr = 0;
         spu->slb_replace = 0;
@@ -2103,6 +2121,7 @@ int spu_restore(struct spu_state *new, struct spu *spu)
         }
         return rc;
 }
+EXPORT_SYMBOL_GPL(spu_restore);
 
 /**
  * spu_harvest - SPU harvest (reset) operation
@@ -2125,6 +2144,7 @@ static void init_prob(struct spu_state *csa)
         csa->spu_chnlcnt_RW[28] = 1;
         csa->spu_chnlcnt_RW[30] = 1;
         csa->prob.spu_runcntl_RW = SPU_RUNCNTL_STOP;
+        csa->prob.mb_stat_R = 0x000400;
 }
 
 static void init_priv1(struct spu_state *csa)
@@ -2193,6 +2213,7 @@ void spu_init_csa(struct spu_state *csa)
         init_priv1(csa);
         init_priv2(csa);
 }
+EXPORT_SYMBOL_GPL(spu_init_csa);
 
 void spu_fini_csa(struct spu_state *csa)
 {
@@ -2203,3 +2224,4 @@ void spu_fini_csa(struct spu_state *csa)
 
         vfree(csa->lscsa);
 }
+EXPORT_SYMBOL_GPL(spu_fini_csa);
diff --git a/arch/powerpc/platforms/iseries/Makefile b/arch/powerpc/platforms/iseries/Makefile
index ce8c0b943fa0..dee4eb4d8bec 100644
--- a/arch/powerpc/platforms/iseries/Makefile
+++ b/arch/powerpc/platforms/iseries/Makefile
@@ -1,9 +1,11 @@
 EXTRA_CFLAGS    += -mno-minimal-toc
 
-obj-y += hvlog.o hvlpconfig.o lpardata.o setup.o mf.o lpevents.o \
+obj-y += hvlog.o hvlpconfig.o lpardata.o setup.o dt_mod.o mf.o lpevents.o \
         hvcall.o proc.o htab.o iommu.o misc.o irq.o
 obj-$(CONFIG_PCI) += pci.o vpdinfo.o
-obj-$(CONFIG_IBMVIO) += vio.o
 obj-$(CONFIG_SMP) += smp.o
 obj-$(CONFIG_VIOPATH) += viopath.o
 obj-$(CONFIG_MODULES) += ksyms.o
+
+$(obj)/dt_mod.o:        $(obj)/dt.o
+        @$(OBJCOPY) --rename-section .rodata.str1.8=.dt_strings $(obj)/dt.o $(obj)/dt_mod.o
diff --git a/arch/powerpc/platforms/iseries/call_pci.h b/arch/powerpc/platforms/iseries/call_pci.h
index 59d4e0ad5cf3..dbdf69850ed9 100644
--- a/arch/powerpc/platforms/iseries/call_pci.h
+++ b/arch/powerpc/platforms/iseries/call_pci.h
@@ -145,6 +145,25 @@ static inline u64 HvCallPci_configLoad16(u16 busNumber, u8 subBusNumber,
         return retVal.rc;
 }
 
+static inline u64 HvCallPci_configLoad32(u16 busNumber, u8 subBusNumber,
+                u8 deviceId, u32 offset, u32 *value)
+{
+        struct HvCallPci_DsaAddr dsa;
+        struct HvCallPci_LoadReturn retVal;
+
+        *((u64*)&dsa) = 0;
+
+        dsa.busNumber = busNumber;
+        dsa.subBusNumber = subBusNumber;
+        dsa.deviceId = deviceId;
+
+        HvCall3Ret16(HvCallPciConfigLoad32, &retVal, *(u64 *)&dsa, offset, 0);
+
+        *value = retVal.value;
+
+        return retVal.rc;
+}
+
 static inline u64 HvCallPci_configStore8(u16 busNumber, u8 subBusNumber,
                 u8 deviceId, u32 offset, u8 value)
 {
diff --git a/arch/powerpc/platforms/iseries/dt.c b/arch/powerpc/platforms/iseries/dt.c
new file mode 100644
index 000000000000..d3444aabe76e
--- /dev/null
+++ b/arch/powerpc/platforms/iseries/dt.c
@@ -0,0 +1,615 @@
+/*
+ *    Copyright (c) 2005-2006 Michael Ellerman, IBM Corporation
+ *
+ *    Description:
+ *      This file contains all the routines to build a flattened device
+ *      tree for a legacy iSeries machine.
+ *
+ *      This program is free software; you can redistribute it and/or
+ *      modify it under the terms of the GNU General Public License
+ *      as published by the Free Software Foundation; either version
+ *      2 of the License, or (at your option) any later version.
+ */
+
+#undef DEBUG
+
+#include <linux/types.h>
+#include <linux/init.h>
+#include <linux/pci.h>
+#include <linux/pci_regs.h>
+#include <linux/pci_ids.h>
+#include <linux/threads.h>
+#include <linux/bitops.h>
+#include <linux/string.h>
+#include <linux/kernel.h>
+#include <linux/if_ether.h>     /* ETH_ALEN */
+
+#include <asm/machdep.h>
+#include <asm/prom.h>
+#include <asm/lppaca.h>
+#include <asm/cputable.h>
+#include <asm/abs_addr.h>
+#include <asm/system.h>
+#include <asm/iseries/hv_types.h>
+#include <asm/iseries/hv_lp_config.h>
+#include <asm/iseries/hv_call_xm.h>
+#include <asm/iseries/it_exp_vpd_panel.h>
+#include <asm/udbg.h>
+
+#include "processor_vpd.h"
+#include "call_hpt.h"
+#include "call_pci.h"
+#include "pci.h"
+
+#ifdef DEBUG
+#define DBG(fmt...) udbg_printf(fmt)
+#else
+#define DBG(fmt...)
+#endif
+
+/*
+ * These are created by the linker script at the start and end
+ * of the section containing all the strings from this file.
+ */
+extern char __dt_strings_start[];
+extern char __dt_strings_end[];
+
+struct iseries_flat_dt {
+        struct boot_param_header header;
+        u64 reserve_map[2];
+};
+
+static void * __initdata dt_data;
+
+/*
+ * Putting these strings here keeps them out of the section
+ * that we rename to .dt_strings using objcopy and capture
+ * for the strings blob of the flattened device tree.
+ */
+static char __initdata device_type_cpu[] = "cpu";
+static char __initdata device_type_memory[] = "memory";
+static char __initdata device_type_serial[] = "serial";
+static char __initdata device_type_network[] = "network";
+static char __initdata device_type_block[] = "block";
+static char __initdata device_type_byte[] = "byte";
+static char __initdata device_type_pci[] = "pci";
+static char __initdata device_type_vdevice[] = "vdevice";
+static char __initdata device_type_vscsi[] = "vscsi";
+
+static struct iseries_flat_dt * __init dt_init(void)
+{
+        struct iseries_flat_dt *dt;
+        unsigned long str_len;
+
+        str_len = __dt_strings_end - __dt_strings_start;
+        dt = (struct iseries_flat_dt *)ALIGN(klimit, 8);
+        dt->header.off_mem_rsvmap =
+                offsetof(struct iseries_flat_dt, reserve_map);
+        dt->header.off_dt_strings = ALIGN(sizeof(*dt), 8);
+        dt->header.off_dt_struct = dt->header.off_dt_strings
+                + ALIGN(str_len, 8);
+        dt_data = (void *)((unsigned long)dt + dt->header.off_dt_struct);
+        dt->header.dt_strings_size = str_len;
+
+        /* There is no notion of hardware cpu id on iSeries */
+        dt->header.boot_cpuid_phys = smp_processor_id();
+
+        memcpy((char *)dt + dt->header.off_dt_strings, __dt_strings_start,
+                        str_len);
+
+        dt->header.magic = OF_DT_HEADER;
+        dt->header.version = 0x10;
+        dt->header.last_comp_version = 0x10;
+
+        dt->reserve_map[0] = 0;
+        dt->reserve_map[1] = 0;
+
+        return dt;
+}
+
+static void __init dt_push_u32(struct iseries_flat_dt *dt, u32 value)
+{
+        *((u32 *)dt_data) = value;
+        dt_data += sizeof(u32);
+}
+
+#ifdef notyet
+static void __init dt_push_u64(struct iseries_flat_dt *dt, u64 value)
+{
+        *((u64 *)dt_data) = value;
+        dt_data += sizeof(u64);
+}
+#endif
+
+static void __init dt_push_bytes(struct iseries_flat_dt *dt, const char *data,
+                int len)
+{
+        memcpy(dt_data, data, len);
+        dt_data += ALIGN(len, 4);
+}
+
+static void __init dt_start_node(struct iseries_flat_dt *dt, const char *name)
+{
+        dt_push_u32(dt, OF_DT_BEGIN_NODE);
+        dt_push_bytes(dt, name, strlen(name) + 1);
+}
+
+#define dt_end_node(dt) dt_push_u32(dt, OF_DT_END_NODE)
+
+static void __init dt_prop(struct iseries_flat_dt *dt, const char *name,
+                const void *data, int len)
+{
+        unsigned long offset;
+
+        dt_push_u32(dt, OF_DT_PROP);
+
+        /* Length of the data */
+        dt_push_u32(dt, len);
+
+        offset = name - __dt_strings_start;
+
+        /* The offset of the properties name in the string blob. */
+        dt_push_u32(dt, (u32)offset);
+
+        /* The actual data. */
+        dt_push_bytes(dt, data, len);
+}
+
+static void __init dt_prop_str(struct iseries_flat_dt *dt, const char *name,
+                const char *data)
+{
+        dt_prop(dt, name, data, strlen(data) + 1); /* + 1 for NULL */
+}
+
+static void __init dt_prop_u32(struct iseries_flat_dt *dt, const char *name,
+                u32 data)
+{
+        dt_prop(dt, name, &data, sizeof(u32));
+}
+
+#ifdef notyet
+static void __init dt_prop_u64(struct iseries_flat_dt *dt, const char *name,
+                u64 data)
+{
+        dt_prop(dt, name, &data, sizeof(u64));
+}
+#endif
+
+static void __init dt_prop_u64_list(struct iseries_flat_dt *dt,
+                const char *name, u64 *data, int n)
+{
+        dt_prop(dt, name, data, sizeof(u64) * n);
+}
+
+static void __init dt_prop_u32_list(struct iseries_flat_dt *dt,
+                const char *name, u32 *data, int n)
+{
+        dt_prop(dt, name, data, sizeof(u32) * n);
+}
+
+#ifdef notyet
+static void __init dt_prop_empty(struct iseries_flat_dt *dt, const char *name)
+{
+        dt_prop(dt, name, NULL, 0);
+}
+#endif
+
+static void __init dt_cpus(struct iseries_flat_dt *dt)
+{
+        unsigned char buf[32];
+        unsigned char *p;
+        unsigned int i, index;
+        struct IoHriProcessorVpd *d;
+        u32 pft_size[2];
+
+        /* yuck */
+        snprintf(buf, 32, "PowerPC,%s", cur_cpu_spec->cpu_name);
+        p = strchr(buf, ' ');
+        if (!p) p = buf + strlen(buf);
+
+        dt_start_node(dt, "cpus");
+        dt_prop_u32(dt, "#address-cells", 1);
+        dt_prop_u32(dt, "#size-cells", 0);
+
+        pft_size[0] = 0; /* NUMA CEC cookie, 0 for non NUMA  */
+        pft_size[1] = __ilog2(HvCallHpt_getHptPages() * HW_PAGE_SIZE);
+
+        for (i = 0; i < NR_CPUS; i++) {
+                if (lppaca[i].dyn_proc_status >= 2)
+                        continue;
+
+                snprintf(p, 32 - (p - buf), "@%d", i);
+                dt_start_node(dt, buf);
+
+                dt_prop_str(dt, "device_type", device_type_cpu);
+
+                index = lppaca[i].dyn_hv_phys_proc_index;
+                d = &xIoHriProcessorVpd[index];
+
+                dt_prop_u32(dt, "i-cache-size", d->xInstCacheSize * 1024);
+                dt_prop_u32(dt, "i-cache-line-size", d->xInstCacheOperandSize);
+
+                dt_prop_u32(dt, "d-cache-size", d->xDataL1CacheSizeKB * 1024);
+                dt_prop_u32(dt, "d-cache-line-size", d->xDataCacheOperandSize);
+
+                /* magic conversions to Hz copied from old code */
+                dt_prop_u32(dt, "clock-frequency",
+                        ((1UL << 34) * 1000000) / d->xProcFreq);
+                dt_prop_u32(dt, "timebase-frequency",
+                        ((1UL << 32) * 1000000) / d->xTimeBaseFreq);
+
+                dt_prop_u32(dt, "reg", i);
+
+                dt_prop_u32_list(dt, "ibm,pft-size", pft_size, 2);
+
+                dt_end_node(dt);
+        }
+
+        dt_end_node(dt);
+}
+
+static void __init dt_model(struct iseries_flat_dt *dt)
+{
+        char buf[16] = "IBM,";
+
+        /* "IBM," + mfgId[2:3] + systemSerial[1:5] */
+        strne2a(buf + 4, xItExtVpdPanel.mfgID + 2, 2);
+        strne2a(buf + 6, xItExtVpdPanel.systemSerial + 1, 5);
+        buf[11] = '\0';
+        dt_prop_str(dt, "system-id", buf);
+
+        /* "IBM," + machineType[0:4] */
+        strne2a(buf + 4, xItExtVpdPanel.machineType, 4);
+        buf[8] = '\0';
+        dt_prop_str(dt, "model", buf);
+
+        dt_prop_str(dt, "compatible", "IBM,iSeries");
+}
+
+static void __init dt_do_vdevice(struct iseries_flat_dt *dt,
+                const char *name, u32 reg, int unit,
+                const char *type, const char *compat, int end)
+{
+        char buf[32];
+
+        snprintf(buf, 32, "%s@%08x", name, reg + ((unit >= 0) ? unit : 0));
+        dt_start_node(dt, buf);
+        dt_prop_str(dt, "device_type", type);
+        if (compat)
+                dt_prop_str(dt, "compatible", compat);
+        dt_prop_u32(dt, "reg", reg + ((unit >= 0) ? unit : 0));
+        if (unit >= 0)
+                dt_prop_u32(dt, "linux,unit_address", unit);
+        if (end)
+                dt_end_node(dt);
+}
+
+static void __init dt_vdevices(struct iseries_flat_dt *dt)
+{
+        u32 reg = 0;
+        HvLpIndexMap vlan_map;
+        int i;
+
+        dt_start_node(dt, "vdevice");
+        dt_prop_str(dt, "device_type", device_type_vdevice);
+        dt_prop_str(dt, "compatible", "IBM,iSeries-vdevice");
+        dt_prop_u32(dt, "#address-cells", 1);
+        dt_prop_u32(dt, "#size-cells", 0);
+
+        dt_do_vdevice(dt, "vty", reg, -1, device_type_serial, NULL, 1);
+        reg++;
+
+        dt_do_vdevice(dt, "v-scsi", reg, -1, device_type_vscsi,
+                        "IBM,v-scsi", 1);
+        reg++;
+
+        vlan_map = HvLpConfig_getVirtualLanIndexMap();
+        for (i = 0; i < HVMAXARCHITECTEDVIRTUALLANS; i++) {
+                unsigned char mac_addr[ETH_ALEN];
+
+                if ((vlan_map & (0x8000 >> i)) == 0)
+                        continue;
+                dt_do_vdevice(dt, "l-lan", reg, i, device_type_network,
+                                "IBM,iSeries-l-lan", 0);
+                mac_addr[0] = 0x02;
+                mac_addr[1] = 0x01;
+                mac_addr[2] = 0xff;
+                mac_addr[3] = i;
+                mac_addr[4] = 0xff;
+                mac_addr[5] = HvLpConfig_getLpIndex_outline();
+                dt_prop(dt, "local-mac-address", (char *)mac_addr, ETH_ALEN);
+                dt_prop(dt, "mac-address", (char *)mac_addr, ETH_ALEN);
+                dt_prop_u32(dt, "max-frame-size", 9000);
+                dt_prop_u32(dt, "address-bits", 48);
+
+                dt_end_node(dt);
+        }
+        reg += HVMAXARCHITECTEDVIRTUALLANS;
+
+        for (i = 0; i < HVMAXARCHITECTEDVIRTUALDISKS; i++)
+                dt_do_vdevice(dt, "viodasd", reg, i, device_type_block,
+                                "IBM,iSeries-viodasd", 1);
+        reg += HVMAXARCHITECTEDVIRTUALDISKS;
+
+        for (i = 0; i < HVMAXARCHITECTEDVIRTUALCDROMS; i++)
+                dt_do_vdevice(dt, "viocd", reg, i, device_type_block,
+                                "IBM,iSeries-viocd", 1);
+        reg += HVMAXARCHITECTEDVIRTUALCDROMS;
+
+        for (i = 0; i < HVMAXARCHITECTEDVIRTUALTAPES; i++)
+                dt_do_vdevice(dt, "viotape", reg, i, device_type_byte,
+                                "IBM,iSeries-viotape", 1);
+
+        dt_end_node(dt);
+}
+
+struct pci_class_name {
+        u16 code;
+        const char *name;
+        const char *type;
+};
+
+static struct pci_class_name __initdata pci_class_name[] = {
+        { PCI_CLASS_NETWORK_ETHERNET, "ethernet", device_type_network },
+};
+
+static struct pci_class_name * __init dt_find_pci_class_name(u16 class_code)
+{
+        struct pci_class_name *cp;
+
+        for (cp = pci_class_name;
+                        cp < &pci_class_name[ARRAY_SIZE(pci_class_name)]; cp++)
+                if (cp->code == class_code)
+                        return cp;
+        return NULL;
+}
+
+/*
+ * This assumes that the node slot is always on the primary bus!
+ */
+static void __init scan_bridge_slot(struct iseries_flat_dt *dt,
+                HvBusNumber bus, struct HvCallPci_BridgeInfo *bridge_info)
+{
+        HvSubBusNumber sub_bus = bridge_info->subBusNumber;
+        u16 vendor_id;
+        u16 device_id;
+        u32 class_id;
+        int err;
+        char buf[32];
+        u32 reg[5];
+        int id_sel = ISERIES_GET_DEVICE_FROM_SUBBUS(sub_bus);
+        int function = ISERIES_GET_FUNCTION_FROM_SUBBUS(sub_bus);
+        HvAgentId eads_id_sel = ISERIES_PCI_AGENTID(id_sel, function);
+        u8 devfn;
+        struct pci_class_name *cp;
+
+        /*
+         * Connect all functions of any device found.
+         */
+        for (id_sel = 1; id_sel <= bridge_info->maxAgents; id_sel++) {
+                for (function = 0; function < 8; function++) {
+                        HvAgentId agent_id = ISERIES_PCI_AGENTID(id_sel,
+                                        function);
+                        err = HvCallXm_connectBusUnit(bus, sub_bus,
+                                        agent_id, 0);
+                        if (err) {
+                                if (err != 0x302)
+                                        DBG("connectBusUnit(%x, %x, %x) %x\n",
+                                                bus, sub_bus, agent_id, err);
+                                continue;
+                        }
+
+                        err = HvCallPci_configLoad16(bus, sub_bus, agent_id,
+                                        PCI_VENDOR_ID, &vendor_id);
+                        if (err) {
+                                DBG("ReadVendor(%x, %x, %x) %x\n",
+                                        bus, sub_bus, agent_id, err);
+                                continue;
+                        }
+                        err = HvCallPci_configLoad16(bus, sub_bus, agent_id,
+                                        PCI_DEVICE_ID, &device_id);
+                        if (err) {
+                                DBG("ReadDevice(%x, %x, %x) %x\n",
+                                        bus, sub_bus, agent_id, err);
+                                continue;
+                        }
+                        err = HvCallPci_configLoad32(bus, sub_bus, agent_id,
+                                        PCI_CLASS_REVISION , &class_id);
+                        if (err) {
+                                DBG("ReadClass(%x, %x, %x) %x\n",
+                                        bus, sub_bus, agent_id, err);
+                                continue;
+                        }
+
+                        devfn = PCI_DEVFN(ISERIES_ENCODE_DEVICE(eads_id_sel),
+                                        function);
+                        cp = dt_find_pci_class_name(class_id >> 16);
+                        if (cp && cp->name)
+                                strncpy(buf, cp->name, sizeof(buf) - 1);
+                        else
+                                snprintf(buf, sizeof(buf), "pci%x,%x",
+                                                vendor_id, device_id);
+                        buf[sizeof(buf) - 1] = '\0';
+                        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
+                                        "@%x", PCI_SLOT(devfn));
+                        buf[sizeof(buf) - 1] = '\0';
+                        if (function != 0)
+                                snprintf(buf + strlen(buf),
+                                        sizeof(buf) - strlen(buf),
+                                        ",%x", function);
+                        dt_start_node(dt, buf);
+                        reg[0] = (bus << 16) | (devfn << 8);
+                        reg[1] = 0;
+                        reg[2] = 0;
+                        reg[3] = 0;
+                        reg[4] = 0;
+                        dt_prop_u32_list(dt, "reg", reg, 5);
+                        if (cp && (cp->type || cp->name))
+                                dt_prop_str(dt, "device_type",
+                                        cp->type ? cp->type : cp->name);
+                        dt_prop_u32(dt, "vendor-id", vendor_id);
+                        dt_prop_u32(dt, "device-id", device_id);
+                        dt_prop_u32(dt, "class-code", class_id >> 8);
+                        dt_prop_u32(dt, "revision-id", class_id & 0xff);
+                        dt_prop_u32(dt, "linux,subbus", sub_bus);
+                        dt_prop_u32(dt, "linux,agent-id", agent_id);
+                        dt_prop_u32(dt, "linux,logical-slot-number",
+                                        bridge_info->logicalSlotNumber);
+                        dt_end_node(dt);
+
+                }
+        }
+}
+
+static void __init scan_bridge(struct iseries_flat_dt *dt, HvBusNumber bus,
+                HvSubBusNumber sub_bus, int id_sel)
+{
+        struct HvCallPci_BridgeInfo bridge_info;
+        HvAgentId agent_id;
+        int function;
+        int ret;
+
+        /* Note: hvSubBus and irq is always be 0 at this level! */
+        for (function = 0; function < 8; ++function) {
+                agent_id = ISERIES_PCI_AGENTID(id_sel, function);
+                ret = HvCallXm_connectBusUnit(bus, sub_bus, agent_id, 0);
+                if (ret != 0) {
+                        if (ret != 0xb)
+                                DBG("connectBusUnit(%x, %x, %x) %x\n",
+                                                bus, sub_bus, agent_id, ret);
+                        continue;
+                }
+                DBG("found device at bus %d idsel %d func %d (AgentId %x)\n",
+                                bus, id_sel, function, agent_id);
+                ret = HvCallPci_getBusUnitInfo(bus, sub_bus, agent_id,
+                                iseries_hv_addr(&bridge_info),
+                                sizeof(struct HvCallPci_BridgeInfo));
+                if (ret != 0)
+                        continue;
+                DBG("bridge info: type %x subbus %x "
+                        "maxAgents %x maxsubbus %x logslot %x\n",
+                        bridge_info.busUnitInfo.deviceType,
+                        bridge_info.subBusNumber,
+                        bridge_info.maxAgents,
+                        bridge_info.maxSubBusNumber,
+                        bridge_info.logicalSlotNumber);
+                if (bridge_info.busUnitInfo.deviceType ==
+                                HvCallPci_BridgeDevice)
+                        scan_bridge_slot(dt, bus, &bridge_info);
+                else
+                        DBG("PCI: Invalid Bridge Configuration(0x%02X)",
+                                bridge_info.busUnitInfo.deviceType);
+        }
+}
+
+static void __init scan_phb(struct iseries_flat_dt *dt, HvBusNumber bus)
+{
+        struct HvCallPci_DeviceInfo dev_info;
+        const HvSubBusNumber sub_bus = 0;       /* EADs is always 0. */
+        int err;
+        int id_sel;
+        const int max_agents = 8;
+
+        /*
+         * Probe for EADs Bridges
+         */
+        for (id_sel = 1; id_sel < max_agents; ++id_sel) {
+                err = HvCallPci_getDeviceInfo(bus, sub_bus, id_sel,
+                                iseries_hv_addr(&dev_info),
+                                sizeof(struct HvCallPci_DeviceInfo));
+                if (err) {
+                        if (err != 0x302)
+                                DBG("getDeviceInfo(%x, %x, %x) %x\n",
+                                                bus, sub_bus, id_sel, err);
+                        continue;
+                }
+                if (dev_info.deviceType != HvCallPci_NodeDevice) {
+                        DBG("PCI: Invalid System Configuration"
+                                        "(0x%02X) for bus 0x%02x id 0x%02x.\n",
+                                        dev_info.deviceType, bus, id_sel);
+                        continue;
+                }
+                scan_bridge(dt, bus, sub_bus, id_sel);
+        }
+}
+
+static void __init dt_pci_devices(struct iseries_flat_dt *dt)
+{
+        HvBusNumber bus;
+        char buf[32];
+        u32 buses[2];
+        int phb_num = 0;
+
+        /* Check all possible buses. */
+        for (bus = 0; bus < 256; bus++) {
+                int err = HvCallXm_testBus(bus);
+
+                if (err) {
+                        /*
+                         * Check for Unexpected Return code, a clue that
+                         * something has gone wrong.
+                         */
+                        if (err != 0x0301)
+                                DBG("Unexpected Return on Probe(0x%02X) "
+                                                "0x%04X\n", bus, err);
+                        continue;
+                }
+                DBG("bus %d appears to exist\n", bus);
+                snprintf(buf, 32, "pci@%d", phb_num);
+                dt_start_node(dt, buf);
+                dt_prop_str(dt, "device_type", device_type_pci);
+                dt_prop_str(dt, "compatible", "IBM,iSeries-Logical-PHB");
+                dt_prop_u32(dt, "#address-cells", 3);
+                dt_prop_u32(dt, "#size-cells", 2);
+                buses[0] = buses[1] = bus;
+                dt_prop_u32_list(dt, "bus-range", buses, 2);
+                scan_phb(dt, bus);
+                dt_end_node(dt);
+                phb_num++;
+        }
+}
+
+static void dt_finish(struct iseries_flat_dt *dt)
+{
+        dt_push_u32(dt, OF_DT_END);
+        dt->header.totalsize = (unsigned long)dt_data - (unsigned long)dt;
+        klimit = ALIGN((unsigned long)dt_data, 8);
+}
+
+void * __init build_flat_dt(unsigned long phys_mem_size)
+{
+        struct iseries_flat_dt *iseries_dt;
+        u64 tmp[2];
+
+        iseries_dt = dt_init();
+
+        dt_start_node(iseries_dt, "");
+
+        dt_prop_u32(iseries_dt, "#address-cells", 2);
+        dt_prop_u32(iseries_dt, "#size-cells", 2);
+        dt_model(iseries_dt);
+
+        /* /memory */
+        dt_start_node(iseries_dt, "memory@0");
+        dt_prop_str(iseries_dt, "device_type", device_type_memory);
+        tmp[0] = 0;
+        tmp[1] = phys_mem_size;
+        dt_prop_u64_list(iseries_dt, "reg", tmp, 2);
+        dt_end_node(iseries_dt);
+
+        /* /chosen */
+        dt_start_node(iseries_dt, "chosen");
+        dt_prop_str(iseries_dt, "bootargs", cmd_line);
+        dt_end_node(iseries_dt);
+
+        dt_cpus(iseries_dt);
+
+        dt_vdevices(iseries_dt);
+        dt_pci_devices(iseries_dt);
+
+        dt_end_node(iseries_dt);
+
+        dt_finish(iseries_dt);
+
+        return iseries_dt;
+}
diff --git a/arch/powerpc/platforms/iseries/iommu.c b/arch/powerpc/platforms/iseries/iommu.c
index bea0b703f409..e3bd2015f2c9 100644
--- a/arch/powerpc/platforms/iseries/iommu.c
+++ b/arch/powerpc/platforms/iseries/iommu.c
@@ -4,6 +4,7 @@
  * Rewrite, cleanup:
  *
  * Copyright (C) 2004 Olof Johansson <olof@lixom.net>, IBM Corporation
+ * Copyright (C) 2006 Olof Johansson <olof@lixom.net>
  *
  * Dynamic DMA mapping support, iSeries-specific parts.
  *
@@ -31,42 +32,37 @@
 #include <asm/tce.h>
 #include <asm/machdep.h>
 #include <asm/abs_addr.h>
+#include <asm/prom.h>
 #include <asm/pci-bridge.h>
 #include <asm/iseries/hv_call_xm.h>
-
-#include "iommu.h"
-
-extern struct list_head iSeries_Global_Device_List;
-
+#include <asm/iseries/iommu.h>
 
 static void tce_build_iSeries(struct iommu_table *tbl, long index, long npages,
                 unsigned long uaddr, enum dma_data_direction direction)
 {
         u64 rc;
-        union tce_entry tce;
+        u64 tce, rpn;
 
         index <<= TCE_PAGE_FACTOR;
         npages <<= TCE_PAGE_FACTOR;
 
         while (npages--) {
-                tce.te_word = 0;
-                tce.te_bits.tb_rpn = virt_to_abs(uaddr) >> TCE_SHIFT;
+                rpn = virt_to_abs(uaddr) >> TCE_SHIFT;
+                tce = (rpn & TCE_RPN_MASK) << TCE_RPN_SHIFT;
 
                 if (tbl->it_type == TCE_VB) {
                         /* Virtual Bus */
-                        tce.te_bits.tb_valid = 1;
-                        tce.te_bits.tb_allio = 1;
+                        tce |= TCE_VALID|TCE_ALLIO;
                         if (direction != DMA_TO_DEVICE)
-                                tce.te_bits.tb_rdwr = 1;
+                                tce |= TCE_VB_WRITE;
                 } else {
                         /* PCI Bus */
-                        tce.te_bits.tb_rdwr = 1; /* Read allowed */
+                        tce |= TCE_PCI_READ; /* Read allowed */
                         if (direction != DMA_TO_DEVICE)
-                                tce.te_bits.tb_pciwr = 1;
+                                tce |= TCE_PCI_WRITE;
                 }
 
-                rc = HvCallXm_setTce((u64)tbl->it_index, (u64)index,
-                                tce.te_word);
+                rc = HvCallXm_setTce((u64)tbl->it_index, (u64)index, tce);
                 if (rc)
                         panic("PCI_DMA: HvCallXm_setTce failed, Rc: 0x%lx\n",
                                         rc);
@@ -124,7 +120,7 @@ void iommu_table_getparms_iSeries(unsigned long busno,
 
         /* itc_size is in pages worth of table, it_size is in # of entries */
         tbl->it_size = ((parms->itc_size * TCE_PAGE_SIZE) /
-                        sizeof(union tce_entry)) >> TCE_PAGE_FACTOR;
+                        TCE_ENTRY_SIZE) >> TCE_PAGE_FACTOR;
         tbl->it_busno = parms->itc_busno;
         tbl->it_offset = parms->itc_offset >> TCE_PAGE_FACTOR;
         tbl->it_index = parms->itc_index;
@@ -142,10 +138,15 @@ void iommu_table_getparms_iSeries(unsigned long busno,
  */
 static struct iommu_table *iommu_table_find(struct iommu_table * tbl)
 {
-        struct pci_dn *pdn;
+        struct device_node *node;
 
-        list_for_each_entry(pdn, &iSeries_Global_Device_List, Device_List) {
-                struct iommu_table *it = pdn->iommu_table;
+        for (node = NULL; (node = of_find_all_nodes(node)); ) {
+                struct pci_dn *pdn = PCI_DN(node);
+                struct iommu_table *it;
+
+                if (pdn == NULL)
+                        continue;
+                it = pdn->iommu_table;
                 if ((it != NULL) &&
                     (it->it_type == TCE_PCI) &&
                     (it->it_offset == tbl->it_offset) &&
@@ -161,15 +162,18 @@ void iommu_devnode_init_iSeries(struct device_node *dn)
 {
         struct iommu_table *tbl;
         struct pci_dn *pdn = PCI_DN(dn);
+        u32 *lsn = (u32 *)get_property(dn, "linux,logical-slot-number", NULL);
+
+        BUG_ON(lsn == NULL);
 
         tbl = kmalloc(sizeof(struct iommu_table), GFP_KERNEL);
 
-        iommu_table_getparms_iSeries(pdn->busno, pdn->LogicalSlot, 0, tbl);
+        iommu_table_getparms_iSeries(pdn->busno, *lsn, 0, tbl);
 
         /* Look for existing tce table */
         pdn->iommu_table = iommu_table_find(tbl);
         if (pdn->iommu_table == NULL)
-                pdn->iommu_table = iommu_init_table(tbl);
+                pdn->iommu_table = iommu_init_table(tbl, -1);
         else
                 kfree(tbl);
 }
diff --git a/arch/powerpc/platforms/iseries/iommu.h b/arch/powerpc/platforms/iseries/iommu.h
deleted file mode 100644
index cb5658fbe657..000000000000
--- a/arch/powerpc/platforms/iseries/iommu.h
+++ /dev/null
@@ -1,35 +0,0 @@
-#ifndef _PLATFORMS_ISERIES_IOMMU_H
-#define _PLATFORMS_ISERIES_IOMMU_H
-
-/*
- * Copyright (C) 2005  Stephen Rothwell, IBM Corporation
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the:
- * Free Software Foundation, Inc.,
- * 59 Temple Place, Suite 330,
- * Boston, MA  02111-1307  USA
- */
-
-struct device_node;
-struct iommu_table;
-
-/* Creates table for an individual device node */
-extern void iommu_devnode_init_iSeries(struct device_node *dn);
-
-/* Get table parameters from HV */
-extern void iommu_table_getparms_iSeries(unsigned long busno,
-                unsigned char slotno, unsigned char virtbus,
-                struct iommu_table *tbl);
-
-#endif /* _PLATFORMS_ISERIES_IOMMU_H */
diff --git a/arch/powerpc/platforms/iseries/irq.c b/arch/powerpc/platforms/iseries/irq.c
index be3fbfc24e6c..62bbbcf5ded3 100644
--- a/arch/powerpc/platforms/iseries/irq.c
+++ b/arch/powerpc/platforms/iseries/irq.c
@@ -42,6 +42,7 @@
 #include <asm/iseries/it_lp_queue.h>
 
 #include "irq.h"
+#include "pci.h"
 #include "call_pci.h"
 
 #if defined(CONFIG_SMP)
@@ -312,12 +313,12 @@ static hw_irq_controller iSeries_IRQ_handler = {
  * Note that sub_bus is always 0 (at the moment at least).
  */
 int __init iSeries_allocate_IRQ(HvBusNumber bus,
-                HvSubBusNumber sub_bus, HvAgentId dev_id)
+                HvSubBusNumber sub_bus, u32 bsubbus)
 {
         int virtirq;
         unsigned int realirq;
-        u8 idsel = (dev_id >> 4);
-        u8 function = dev_id & 7;
+        u8 idsel = ISERIES_GET_DEVICE_FROM_SUBBUS(bsubbus);
+        u8 function = ISERIES_GET_FUNCTION_FROM_SUBBUS(bsubbus);
 
         realirq = (((((sub_bus << 8) + (bus - 1)) << 3) + (idsel - 1)) << 3)
                 + function;
diff --git a/arch/powerpc/platforms/iseries/irq.h b/arch/powerpc/platforms/iseries/irq.h
index b9c801ba5a47..188aa808abd7 100644
--- a/arch/powerpc/platforms/iseries/irq.h
+++ b/arch/powerpc/platforms/iseries/irq.h
@@ -2,7 +2,7 @@
 #define _ISERIES_IRQ_H
 
 extern void iSeries_init_IRQ(void);
-extern int  iSeries_allocate_IRQ(HvBusNumber, HvSubBusNumber, HvAgentId);
+extern int  iSeries_allocate_IRQ(HvBusNumber, HvSubBusNumber, u32);
 extern void iSeries_activate_IRQs(void);
 extern int iSeries_get_irq(struct pt_regs *);
 
diff --git a/arch/powerpc/platforms/iseries/mf.c b/arch/powerpc/platforms/iseries/mf.c
index d771b8ee857d..1a2c2a50f922 100644
--- a/arch/powerpc/platforms/iseries/mf.c
+++ b/arch/powerpc/platforms/iseries/mf.c
@@ -45,7 +45,6 @@
 
 #include "setup.h"
 
-extern int piranha_simulator;
 static int mf_initialized;
 
 /*
@@ -658,7 +657,7 @@ static void mf_clear_src(void)
 
 void __init mf_display_progress(u16 value)
 {
-        if (piranha_simulator || !mf_initialized)
+        if (!mf_initialized)
                 return;
 
         if (0xFFFF == value)
@@ -1295,9 +1294,6 @@ __initcall(mf_proc_init);
  */
 void iSeries_get_rtc_time(struct rtc_time *rtc_tm)
 {
-        if (piranha_simulator)
-                return;
-
         mf_get_rtc(rtc_tm);
         rtc_tm->tm_mon--;
 }
@@ -1316,9 +1312,6 @@ unsigned long iSeries_get_boot_time(void)
 {
         struct rtc_time tm;
 
-        if (piranha_simulator)
-                return 0;
-
         mf_get_boot_rtc(&tm);
         return mktime(tm.tm_year + 1900, tm.tm_mon, tm.tm_mday,
                       tm.tm_hour, tm.tm_min, tm.tm_sec);
diff --git a/arch/powerpc/platforms/iseries/pci.c b/arch/powerpc/platforms/iseries/pci.c
index a19833b880e4..35bcc98111f5 100644
--- a/arch/powerpc/platforms/iseries/pci.c
+++ b/arch/powerpc/platforms/iseries/pci.c
@@ -37,36 +37,18 @@
 
 #include <asm/iseries/hv_call_xm.h>
 #include <asm/iseries/mf.h>
+#include <asm/iseries/iommu.h>
 
 #include <asm/ppc-pci.h>
 
 #include "irq.h"
 #include "pci.h"
 #include "call_pci.h"
-#include "iommu.h"
-
-extern unsigned long io_page_mask;
 
 /*
  * Forward declares of prototypes.
  */
 static struct device_node *find_Device_Node(int bus, int devfn);
-static void scan_PHB_slots(struct pci_controller *Phb);
-static void scan_EADS_bridge(HvBusNumber Bus, HvSubBusNumber SubBus, int IdSel);
-static int scan_bridge_slot(HvBusNumber Bus, struct HvCallPci_BridgeInfo *Info);
-
-LIST_HEAD(iSeries_Global_Device_List);
-
-static int DeviceCount;
-
-/* Counters and control flags. */
-static long Pci_Io_Read_Count;
-static long Pci_Io_Write_Count;
-#if 0
-static long Pci_Cfg_Read_Count;
-static long Pci_Cfg_Write_Count;
-#endif
-static long Pci_Error_Count;
 
 static int Pci_Retry_Max = 3;   /* Only retry 3 times  */
 static int Pci_Error_Flag = 1;  /* Set Retry Error on. */
@@ -81,41 +63,19 @@ static struct pci_ops iSeries_pci_ops;
 #define IOMM_TABLE_ENTRY_SIZE   0x0000000000400000UL
 #define BASE_IO_MEMORY          0xE000000000000000UL
 
-static unsigned long max_io_memory = 0xE000000000000000UL;
+static unsigned long max_io_memory = BASE_IO_MEMORY;
 static long current_iomm_table_entry;
 
 /*
  * Lookup Tables.
  */
-static struct device_node **iomm_table;
-static u8 *iobar_table;
+static struct device_node *iomm_table[IOMM_TABLE_MAX_ENTRIES];
+static u8 iobar_table[IOMM_TABLE_MAX_ENTRIES];
 
-/*
- * Static and Global variables
- */
-static char *pci_io_text = "iSeries PCI I/O";
+static const char pci_io_text[] = "iSeries PCI I/O";
 static DEFINE_SPINLOCK(iomm_table_lock);
 
 /*
- * iomm_table_initialize
- *
- * Allocates and initalizes the Address Translation Table and Bar
- * Tables to get them ready for use.  Must be called before any
- * I/O space is handed out to the device BARs.
- */
-static void iomm_table_initialize(void)
-{
-        spin_lock(&iomm_table_lock);
-        iomm_table = kmalloc(sizeof(*iomm_table) * IOMM_TABLE_MAX_ENTRIES,
-                        GFP_KERNEL);
-        iobar_table = kmalloc(sizeof(*iobar_table) * IOMM_TABLE_MAX_ENTRIES,
-                        GFP_KERNEL);
-        spin_unlock(&iomm_table_lock);
-        if ((iomm_table == NULL) || (iobar_table == NULL))
-                panic("PCI: I/O tables allocation failed.\n");
-}
-
-/*
  * iomm_table_allocate_entry
  *
  * Adds pci_dev entry in address translation table
@@ -142,9 +102,8 @@ static void iomm_table_allocate_entry(struct pci_dev *dev, int bar_num)
          */
         spin_lock(&iomm_table_lock);
         bar_res->name = pci_io_text;
-        bar_res->start =
+        bar_res->start = BASE_IO_MEMORY +
                 IOMM_TABLE_ENTRY_SIZE * current_iomm_table_entry;
-        bar_res->start += BASE_IO_MEMORY;
         bar_res->end = bar_res->start + bar_size - 1;
         /*
          * Allocate the number of table entries needed for BAR.
@@ -156,7 +115,7 @@ static void iomm_table_allocate_entry(struct pci_dev *dev, int bar_num)
                 ++current_iomm_table_entry;
         }
         max_io_memory = BASE_IO_MEMORY +
-                (IOMM_TABLE_ENTRY_SIZE * current_iomm_table_entry);
+                IOMM_TABLE_ENTRY_SIZE * current_iomm_table_entry;
         spin_unlock(&iomm_table_lock);
 }
 
@@ -173,13 +132,10 @@ static void iomm_table_allocate_entry(struct pci_dev *dev, int bar_num)
  */
 static void allocate_device_bars(struct pci_dev *dev)
 {
-        struct resource *bar_res;
         int bar_num;
 
-        for (bar_num = 0; bar_num <= PCI_ROM_RESOURCE; ++bar_num) {
-                bar_res = &dev->resource[bar_num];
+        for (bar_num = 0; bar_num <= PCI_ROM_RESOURCE; ++bar_num)
                 iomm_table_allocate_entry(dev, bar_num);
-        }
 }
 
 /*
@@ -199,34 +155,7 @@ static void pci_Log_Error(char *Error_Text, int Bus, int SubBus,
 }
 
 /*
- * build_device_node(u16 Bus, int SubBus, u8 DevFn)
- */
-static struct device_node *build_device_node(HvBusNumber Bus,
-                HvSubBusNumber SubBus, int AgentId, int Function)
-{
-        struct device_node *node;
-        struct pci_dn *pdn;
-
-        node = kmalloc(sizeof(struct device_node), GFP_KERNEL);
-        if (node == NULL)
-                return NULL;
-        memset(node, 0, sizeof(struct device_node));
-        pdn = kzalloc(sizeof(*pdn), GFP_KERNEL);
-        if (pdn == NULL) {
-                kfree(node);
-                return NULL;
-        }
-        node->data = pdn;
-        pdn->node = node;
-        list_add_tail(&pdn->Device_List, &iSeries_Global_Device_List);
-        pdn->busno = Bus;
-        pdn->bussubno = SubBus;
-        pdn->devfn = PCI_DEVFN(ISERIES_ENCODE_DEVICE(AgentId), Function);
-        return node;
-}
-
-/*
- * unsigned long __init find_and_init_phbs(void)
+ * iSeries_pcibios_init
  *
  * Description:
  *   This function checks for all possible system PCI host bridges that connect
@@ -234,50 +163,42 @@ static struct device_node *build_device_node(HvBusNumber Bus,
  *   ownership status.  A pci_controller is built for any bus which is partially
  *   owned or fully owned by this guest partition.
  */
-unsigned long __init find_and_init_phbs(void)
+void iSeries_pcibios_init(void)
 {
         struct pci_controller *phb;
-        HvBusNumber bus;
-
-        /* Check all possible buses. */
-        for (bus = 0; bus < 256; bus++) {
-                int ret = HvCallXm_testBus(bus);
-                if (ret == 0) {
-                        printk("bus %d appears to exist\n", bus);
+        struct device_node *root = of_find_node_by_path("/");
+        struct device_node *node = NULL;
 
-                        phb = pcibios_alloc_controller(NULL);
-                        if (phb == NULL)
-                                return -ENOMEM;
-
-                        phb->pci_mem_offset = phb->local_number = bus;
-                        phb->first_busno = bus;
-                        phb->last_busno = bus;
-                        phb->ops = &iSeries_pci_ops;
-
-                        /* Find and connect the devices. */
-                        scan_PHB_slots(phb);
-                }
-                /*
-                 * Check for Unexpected Return code, a clue that something
-                 * has gone wrong.
-                 */
-                else if (ret != 0x0301)
-                        printk(KERN_ERR "Unexpected Return on Probe(0x%04X): 0x%04X",
-                               bus, ret);
+        if (root == NULL) {
+                printk(KERN_CRIT "iSeries_pcibios_init: can't find root "
+                                "of device tree\n");
+                return;
+        }
+        while ((node = of_get_next_child(root, node)) != NULL) {
+                HvBusNumber bus;
+                u32 *busp;
+
+                if ((node->type == NULL) || (strcmp(node->type, "pci") != 0))
+                        continue;
+
+                busp = (u32 *)get_property(node, "bus-range", NULL);
+                if (busp == NULL)
+                        continue;
+                bus = *busp;
+                printk("bus %d appears to exist\n", bus);
+                phb = pcibios_alloc_controller(node);
+                if (phb == NULL)
+                        continue;
+
+                phb->pci_mem_offset = phb->local_number = bus;
+                phb->first_busno = bus;
+                phb->last_busno = bus;
+                phb->ops = &iSeries_pci_ops;
         }
-        return 0;
-}
 
-/*
- * iSeries_pcibios_init
- *
- * Chance to initialize and structures or variable before PCI Bus walk.
- */
-void iSeries_pcibios_init(void)
-{
-        iomm_table_initialize();
-        find_and_init_phbs();
-        io_page_mask = -1;
+        of_node_put(root);
+
+        pci_devs_phb_init();
 }
 
 /*
@@ -299,6 +220,34 @@ void __init iSeries_pci_final_fixup(void)
                        pdev->bus->number, pdev->devfn, node);
 
                 if (node != NULL) {
+                        struct pci_dn *pdn = PCI_DN(node);
+                        u32 *agent;
+
+                        agent = (u32 *)get_property(node, "linux,agent-id",
+                                        NULL);
+                        if ((pdn != NULL) && (agent != NULL)) {
+                                u8 irq = iSeries_allocate_IRQ(pdn->busno, 0,
+                                                pdn->bussubno);
+                                int err;
+
+                                err = HvCallXm_connectBusUnit(pdn->busno, pdn->bussubno,
+                                                *agent, irq);
+                                if (err)
+                                        pci_Log_Error("Connect Bus Unit",
+                                                pdn->busno, pdn->bussubno, *agent, err);
+                                else {
+                                        err = HvCallPci_configStore8(pdn->busno, pdn->bussubno,
+                                                        *agent,
+                                                        PCI_INTERRUPT_LINE,
+                                                        irq);
+                                        if (err)
+                                                pci_Log_Error("PciCfgStore Irq Failed!",
+                                                        pdn->busno, pdn->bussubno, *agent, err);
+                                }
+                                if (!err)
+                                        pdev->irq = irq;
+                        }
+
                         ++DeviceCount;
                         pdev->sysdata = (void *)node;
                         PCI_DN(node)->pcidev = pdev;
@@ -308,7 +257,6 @@ void __init iSeries_pci_final_fixup(void)
                 } else
                         printk("PCI: Device Tree not found for 0x%016lX\n",
                                         (unsigned long)pdev);
-                pdev->irq = PCI_DN(node)->Irq;
         }
         iSeries_activate_IRQs();
         mf_display_src(0xC9000200);
@@ -323,148 +271,6 @@ void pcibios_fixup_resources(struct pci_dev *pdev)
 }
 
 /*
- * Loop through each node function to find usable EADs bridges.
- */
-static void scan_PHB_slots(struct pci_controller *Phb)
-{
-        struct HvCallPci_DeviceInfo *DevInfo;
-        HvBusNumber bus = Phb->local_number;    /* System Bus */
-        const HvSubBusNumber SubBus = 0;        /* EADs is always 0. */
-        int HvRc = 0;
-        int IdSel;
-        const int MaxAgents = 8;
-
-        DevInfo = (struct HvCallPci_DeviceInfo*)
-                kmalloc(sizeof(struct HvCallPci_DeviceInfo), GFP_KERNEL);
-        if (DevInfo == NULL)
-                return;
-
-        /*
-         * Probe for EADs Bridges
-         */
-        for (IdSel = 1; IdSel < MaxAgents; ++IdSel) {
-                HvRc = HvCallPci_getDeviceInfo(bus, SubBus, IdSel,
-                                iseries_hv_addr(DevInfo),
-                                sizeof(struct HvCallPci_DeviceInfo));
-                if (HvRc == 0) {
-                        if (DevInfo->deviceType == HvCallPci_NodeDevice)
-                                scan_EADS_bridge(bus, SubBus, IdSel);
-                        else
-                                printk("PCI: Invalid System Configuration(0x%02X)"
-                                       " for bus 0x%02x id 0x%02x.\n",
-                                       DevInfo->deviceType, bus, IdSel);
-                }
-                else
-                        pci_Log_Error("getDeviceInfo", bus, SubBus, IdSel, HvRc);
-        }
-        kfree(DevInfo);
-}
-
-static void scan_EADS_bridge(HvBusNumber bus, HvSubBusNumber SubBus,
-                int IdSel)
-{
-        struct HvCallPci_BridgeInfo *BridgeInfo;
-        HvAgentId AgentId;
-        int Function;
-        int HvRc;
-
-        BridgeInfo = (struct HvCallPci_BridgeInfo *)
-                kmalloc(sizeof(struct HvCallPci_BridgeInfo), GFP_KERNEL);
-        if (BridgeInfo == NULL)
-                return;
-
-        /* Note: hvSubBus and irq is always be 0 at this level! */
-        for (Function = 0; Function < 8; ++Function) {
-                AgentId = ISERIES_PCI_AGENTID(IdSel, Function);
-                HvRc = HvCallXm_connectBusUnit(bus, SubBus, AgentId, 0);
-                if (HvRc == 0) {
-                        printk("found device at bus %d idsel %d func %d (AgentId %x)\n",
-                               bus, IdSel, Function, AgentId);
-                        /*  Connect EADs: 0x18.00.12 = 0x00 */
-                        HvRc = HvCallPci_getBusUnitInfo(bus, SubBus, AgentId,
-                                        iseries_hv_addr(BridgeInfo),
-                                        sizeof(struct HvCallPci_BridgeInfo));
-                        if (HvRc == 0) {
-                                printk("bridge info: type %x subbus %x maxAgents %x maxsubbus %x logslot %x\n",
-                                        BridgeInfo->busUnitInfo.deviceType,
-                                        BridgeInfo->subBusNumber,
-                                        BridgeInfo->maxAgents,
-                                        BridgeInfo->maxSubBusNumber,
-                                        BridgeInfo->logicalSlotNumber);
-                                if (BridgeInfo->busUnitInfo.deviceType ==
-                                                HvCallPci_BridgeDevice)  {
-                                        /* Scan_Bridge_Slot...: 0x18.00.12 */
-                                        scan_bridge_slot(bus, BridgeInfo);
-                                } else
-                                        printk("PCI: Invalid Bridge Configuration(0x%02X)",
-                                                BridgeInfo->busUnitInfo.deviceType);
-                        }
-                } else if (HvRc != 0x000B)
-                        pci_Log_Error("EADs Connect",
-                                        bus, SubBus, AgentId, HvRc);
-        }
-        kfree(BridgeInfo);
-}
-
-/*
- * This assumes that the node slot is always on the primary bus!
- */
-static int scan_bridge_slot(HvBusNumber Bus,
-                struct HvCallPci_BridgeInfo *BridgeInfo)
-{
-        struct device_node *node;
-        HvSubBusNumber SubBus = BridgeInfo->subBusNumber;
-        u16 VendorId = 0;
-        int HvRc = 0;
-        u8 Irq = 0;
-        int IdSel = ISERIES_GET_DEVICE_FROM_SUBBUS(SubBus);
-        int Function = ISERIES_GET_FUNCTION_FROM_SUBBUS(SubBus);
-        HvAgentId EADsIdSel = ISERIES_PCI_AGENTID(IdSel, Function);
-
-        /* iSeries_allocate_IRQ.: 0x18.00.12(0xA3) */
-        Irq = iSeries_allocate_IRQ(Bus, 0, EADsIdSel);
-
-        /*
-         * Connect all functions of any device found.
-         */
-        for (IdSel = 1; IdSel <= BridgeInfo->maxAgents; ++IdSel) {
-                for (Function = 0; Function < 8; ++Function) {
-                        HvAgentId AgentId = ISERIES_PCI_AGENTID(IdSel, Function);
-                        HvRc = HvCallXm_connectBusUnit(Bus, SubBus,
-                                        AgentId, Irq);
-                        if (HvRc != 0) {
-                                pci_Log_Error("Connect Bus Unit",
-                                              Bus, SubBus, AgentId, HvRc);
-                                continue;
-                        }
-
-                        HvRc = HvCallPci_configLoad16(Bus, SubBus, AgentId,
-                                                      PCI_VENDOR_ID, &VendorId);
-                        if (HvRc != 0) {
-                                pci_Log_Error("Read Vendor",
-                                              Bus, SubBus, AgentId, HvRc);
-                                continue;
-                        }
-                        printk("read vendor ID: %x\n", VendorId);
-
-                        /* FoundDevice: 0x18.28.10 = 0x12AE */
-                        HvRc = HvCallPci_configStore8(Bus, SubBus, AgentId,
-                                                      PCI_INTERRUPT_LINE, Irq);
-                        if (HvRc != 0)
-                                pci_Log_Error("PciCfgStore Irq Failed!",
-                                              Bus, SubBus, AgentId, HvRc);
-
-                        ++DeviceCount;
-                        node = build_device_node(Bus, SubBus, EADsIdSel, Function);
-                        PCI_DN(node)->Irq = Irq;
-                        PCI_DN(node)->LogicalSlot = BridgeInfo->logicalSlotNumber;
-
-                } /* for (Function = 0; Function < 8; ++Function) */
-        } /* for (IdSel = 1; IdSel <= MaxAgents; ++IdSel) */
-        return HvRc;
-}
-
-/*
  * I/0 Memory copy MUST use mmio commands on iSeries
  * To do; For performance, include the hv call directly
  */
@@ -509,11 +315,13 @@ EXPORT_SYMBOL(iSeries_memcpy_fromio);
  */
 static struct device_node *find_Device_Node(int bus, int devfn)
 {
-        struct pci_dn *pdn;
+        struct device_node *node;
+
+        for (node = NULL; (node = of_find_all_nodes(node)); ) {
+                struct pci_dn *pdn = PCI_DN(node);
 
-        list_for_each_entry(pdn, &iSeries_Global_Device_List, Device_List) {
-                if ((bus == pdn->busno) && (devfn == pdn->devfn))
-                        return pdn->node;
+                if (pdn && (bus == pdn->busno) && (devfn == pdn->devfn))
+                        return node;
         }
         return NULL;
 }
@@ -625,7 +433,6 @@ static int CheckReturnCode(char *TextHdr, struct device_node *DevNode,
         if (ret != 0)  {
                 struct pci_dn *pdn = PCI_DN(DevNode);
 
-                ++Pci_Error_Count;
                 (*retry)++;
                 printk("PCI: %s: Device 0x%04X:%02X  I/O Error(%2d): 0x%04X\n",
                                 TextHdr, pdn->busno, pdn->devfn,
@@ -707,7 +514,6 @@ u8 iSeries_Read_Byte(const volatile void __iomem *IoAddress)
                 return 0xff;
         }
         do {
-                ++Pci_Io_Read_Count;
                 HvCall3Ret16(HvCallPciBarLoad8, &ret, dsa, BarOffset, 0);
         } while (CheckReturnCode("RDB", DevNode, &retry, ret.rc) != 0);
 
@@ -737,7 +543,6 @@ u16 iSeries_Read_Word(const volatile void __iomem *IoAddress)
                 return 0xffff;
         }
         do {
-                ++Pci_Io_Read_Count;
                 HvCall3Ret16(HvCallPciBarLoad16, &ret, dsa,
                                 BarOffset, 0);
         } while (CheckReturnCode("RDW", DevNode, &retry, ret.rc) != 0);
@@ -768,7 +573,6 @@ u32 iSeries_Read_Long(const volatile void __iomem *IoAddress)
                 return 0xffffffff;
         }
         do {
-                ++Pci_Io_Read_Count;
                 HvCall3Ret16(HvCallPciBarLoad32, &ret, dsa,
                                 BarOffset, 0);
         } while (CheckReturnCode("RDL", DevNode, &retry, ret.rc) != 0);
@@ -806,7 +610,6 @@ void iSeries_Write_Byte(u8 data, volatile void __iomem *IoAddress)
                 return;
         }
         do {
-                ++Pci_Io_Write_Count;
                 rc = HvCall4(HvCallPciBarStore8, dsa, BarOffset, data, 0);
         } while (CheckReturnCode("WWB", DevNode, &retry, rc) != 0);
 }
@@ -834,7 +637,6 @@ void iSeries_Write_Word(u16 data, volatile void __iomem *IoAddress)
                 return;
         }
         do {
-                ++Pci_Io_Write_Count;
                 rc = HvCall4(HvCallPciBarStore16, dsa, BarOffset, swab16(data), 0);
         } while (CheckReturnCode("WWW", DevNode, &retry, rc) != 0);
 }
@@ -862,7 +664,6 @@ void iSeries_Write_Long(u32 data, volatile void __iomem *IoAddress)
                 return;
         }
         do {
-                ++Pci_Io_Write_Count;
                 rc = HvCall4(HvCallPciBarStore32, dsa, BarOffset, swab32(data), 0);
         } while (CheckReturnCode("WWL", DevNode, &retry, rc) != 0);
 }
diff --git a/arch/powerpc/platforms/iseries/setup.c b/arch/powerpc/platforms/iseries/setup.c
index a6fd9bedb074..617c724c4590 100644
--- a/arch/powerpc/platforms/iseries/setup.c
+++ b/arch/powerpc/platforms/iseries/setup.c
@@ -50,7 +50,6 @@
 #include <asm/iseries/hv_call_xm.h>
 #include <asm/iseries/it_lp_queue.h>
 #include <asm/iseries/mf.h>
-#include <asm/iseries/it_exp_vpd_panel.h>
 #include <asm/iseries/hv_lp_event.h>
 #include <asm/iseries/lpar_map.h>
 #include <asm/udbg.h>
@@ -81,9 +80,6 @@ extern void iSeries_pci_final_fixup(void);
 static void iSeries_pci_final_fixup(void) { }
 #endif
 
-/* Global Variables */
-int piranha_simulator;
-
 extern int rd_size;             /* Defined in drivers/block/rd.c */
 extern unsigned long embedded_sysmap_start;
 extern unsigned long embedded_sysmap_end;
@@ -91,8 +87,6 @@ extern unsigned long embedded_sysmap_end;
 extern unsigned long iSeries_recal_tb;
 extern unsigned long iSeries_recal_titan;
 
-static unsigned long cmd_mem_limit;
-
 struct MemoryBlock {
         unsigned long absStart;
         unsigned long absEnd;
@@ -340,8 +334,6 @@ static void __init iSeries_init_early(void)
 #ifdef CONFIG_SMP
         smp_init_iSeries();
 #endif
-        if (itLpNaca.xPirEnvironMode == 0)
-                piranha_simulator = 1;
 
         /* Associate Lp Event Queue 0 with processor 0 */
         HvCallEvent_setLpEventQueueInterruptProc(0, 0);
@@ -536,10 +528,10 @@ static void __init iSeries_setup_arch(void)
 {
         if (get_lppaca()->shared_proc) {
                 ppc_md.idle_loop = iseries_shared_idle;
-                printk(KERN_INFO "Using shared processor idle loop\n");
+                printk(KERN_DEBUG "Using shared processor idle loop\n");
         } else {
                 ppc_md.idle_loop = iseries_dedicated_idle;
-                printk(KERN_INFO "Using dedicated idle loop\n");
+                printk(KERN_DEBUG "Using dedicated idle loop\n");
         }
 
         /* Setup the Lp Event Queue */
@@ -714,243 +706,6 @@ define_machine(iseries) {
         /* XXX Implement enable_pmcs for iSeries */
 };
 
-struct blob {
-        unsigned char data[PAGE_SIZE];
-        unsigned long next;
-};
-
-struct iseries_flat_dt {
-        struct boot_param_header header;
-        u64 reserve_map[2];
-        struct blob dt;
-        struct blob strings;
-};
-
-struct iseries_flat_dt iseries_dt;
-
-void dt_init(struct iseries_flat_dt *dt)
-{
-        dt->header.off_mem_rsvmap =
-                offsetof(struct iseries_flat_dt, reserve_map);
-        dt->header.off_dt_struct = offsetof(struct iseries_flat_dt, dt);
-        dt->header.off_dt_strings = offsetof(struct iseries_flat_dt, strings);
-        dt->header.totalsize = sizeof(struct iseries_flat_dt);
-        dt->header.dt_strings_size = sizeof(struct blob);
-
-        /* There is no notion of hardware cpu id on iSeries */
-        dt->header.boot_cpuid_phys = smp_processor_id();
-
-        dt->dt.next = (unsigned long)&dt->dt.data;
-        dt->strings.next = (unsigned long)&dt->strings.data;
-
-        dt->header.magic = OF_DT_HEADER;
-        dt->header.version = 0x10;
-        dt->header.last_comp_version = 0x10;
-
-        dt->reserve_map[0] = 0;
-        dt->reserve_map[1] = 0;
-}
-
-void dt_check_blob(struct blob *b)
-{
-        if (b->next >= (unsigned long)&b->next) {
-                DBG("Ran out of space in flat device tree blob!\n");
-                BUG();
-        }
-}
-
-void dt_push_u32(struct iseries_flat_dt *dt, u32 value)
-{
-        *((u32*)dt->dt.next) = value;
-        dt->dt.next += sizeof(u32);
-
-        dt_check_blob(&dt->dt);
-}
-
-void dt_push_u64(struct iseries_flat_dt *dt, u64 value)
-{
-        *((u64*)dt->dt.next) = value;
-        dt->dt.next += sizeof(u64);
-
-        dt_check_blob(&dt->dt);
-}
-
-unsigned long dt_push_bytes(struct blob *blob, char *data, int len)
-{
-        unsigned long start = blob->next - (unsigned long)blob->data;
-
-        memcpy((char *)blob->next, data, len);
-        blob->next = _ALIGN(blob->next + len, 4);
-
-        dt_check_blob(blob);
-
-        return start;
-}
-
-void dt_start_node(struct iseries_flat_dt *dt, char *name)
-{
-        dt_push_u32(dt, OF_DT_BEGIN_NODE);
-        dt_push_bytes(&dt->dt, name, strlen(name) + 1);
-}
-
-#define dt_end_node(dt) dt_push_u32(dt, OF_DT_END_NODE)
-
-void dt_prop(struct iseries_flat_dt *dt, char *name, char *data, int len)
-{
-        unsigned long offset;
-
-        dt_push_u32(dt, OF_DT_PROP);
-
-        /* Length of the data */
-        dt_push_u32(dt, len);
-
-        /* Put the property name in the string blob. */
-        offset = dt_push_bytes(&dt->strings, name, strlen(name) + 1);
-
-        /* The offset of the properties name in the string blob. */
-        dt_push_u32(dt, (u32)offset);
-
-        /* The actual data. */
-        dt_push_bytes(&dt->dt, data, len);
-}
-
-void dt_prop_str(struct iseries_flat_dt *dt, char *name, char *data)
-{
-        dt_prop(dt, name, data, strlen(data) + 1); /* + 1 for NULL */
-}
-
-void dt_prop_u32(struct iseries_flat_dt *dt, char *name, u32 data)
-{
-        dt_prop(dt, name, (char *)&data, sizeof(u32));
-}
-
-void dt_prop_u64(struct iseries_flat_dt *dt, char *name, u64 data)
-{
-        dt_prop(dt, name, (char *)&data, sizeof(u64));
-}
-
-void dt_prop_u64_list(struct iseries_flat_dt *dt, char *name, u64 *data, int n)
-{
-        dt_prop(dt, name, (char *)data, sizeof(u64) * n);
-}
-
-void dt_prop_u32_list(struct iseries_flat_dt *dt, char *name, u32 *data, int n)
-{
-        dt_prop(dt, name, (char *)data, sizeof(u32) * n);
-}
-
-void dt_prop_empty(struct iseries_flat_dt *dt, char *name)
-{
-        dt_prop(dt, name, NULL, 0);
-}
-
-void dt_cpus(struct iseries_flat_dt *dt)
-{
-        unsigned char buf[32];
-        unsigned char *p;
-        unsigned int i, index;
-        struct IoHriProcessorVpd *d;
-        u32 pft_size[2];
-
-        /* yuck */
-        snprintf(buf, 32, "PowerPC,%s", cur_cpu_spec->cpu_name);
-        p = strchr(buf, ' ');
-        if (!p) p = buf + strlen(buf);
-
-        dt_start_node(dt, "cpus");
-        dt_prop_u32(dt, "#address-cells", 1);
-        dt_prop_u32(dt, "#size-cells", 0);
-
-        pft_size[0] = 0; /* NUMA CEC cookie, 0 for non NUMA  */
-        pft_size[1] = __ilog2(HvCallHpt_getHptPages() * HW_PAGE_SIZE);
-
-        for (i = 0; i < NR_CPUS; i++) {
-                if (lppaca[i].dyn_proc_status >= 2)
-                        continue;
-
-                snprintf(p, 32 - (p - buf), "@%d", i);
-                dt_start_node(dt, buf);
-
-                dt_prop_str(dt, "device_type", "cpu");
-
-                index = lppaca[i].dyn_hv_phys_proc_index;
-                d = &xIoHriProcessorVpd[index];
-
-                dt_prop_u32(dt, "i-cache-size", d->xInstCacheSize * 1024);
-                dt_prop_u32(dt, "i-cache-line-size", d->xInstCacheOperandSize);
-
-                dt_prop_u32(dt, "d-cache-size", d->xDataL1CacheSizeKB * 1024);
-                dt_prop_u32(dt, "d-cache-line-size", d->xDataCacheOperandSize);
-
-                /* magic conversions to Hz copied from old code */
-                dt_prop_u32(dt, "clock-frequency",
-                        ((1UL << 34) * 1000000) / d->xProcFreq);
-                dt_prop_u32(dt, "timebase-frequency",
-                        ((1UL << 32) * 1000000) / d->xTimeBaseFreq);
-
-                dt_prop_u32(dt, "reg", i);
-
-                dt_prop_u32_list(dt, "ibm,pft-size", pft_size, 2);
-
-                dt_end_node(dt);
-        }
-
-        dt_end_node(dt);
-}
-
-void dt_model(struct iseries_flat_dt *dt)
-{
-        char buf[16] = "IBM,";
-
-        /* "IBM," + mfgId[2:3] + systemSerial[1:5] */
-        strne2a(buf + 4, xItExtVpdPanel.mfgID + 2, 2);
-        strne2a(buf + 6, xItExtVpdPanel.systemSerial + 1, 5);
-        buf[11] = '\0';
-        dt_prop_str(dt, "system-id", buf);
-
-        /* "IBM," + machineType[0:4] */
-        strne2a(buf + 4, xItExtVpdPanel.machineType, 4);
-        buf[8] = '\0';
-        dt_prop_str(dt, "model", buf);
-
-        dt_prop_str(dt, "compatible", "IBM,iSeries");
-}
-
-void build_flat_dt(struct iseries_flat_dt *dt, unsigned long phys_mem_size)
-{
-        u64 tmp[2];
-
-        dt_init(dt);
-
-        dt_start_node(dt, "");
-
-        dt_prop_u32(dt, "#address-cells", 2);
-        dt_prop_u32(dt, "#size-cells", 2);
-        dt_model(dt);
-
-        /* /memory */
-        dt_start_node(dt, "memory@0");
-        dt_prop_str(dt, "name", "memory");
-        dt_prop_str(dt, "device_type", "memory");
-        tmp[0] = 0;
-        tmp[1] = phys_mem_size;
-        dt_prop_u64_list(dt, "reg", tmp, 2);
-        dt_end_node(dt);
-
-        /* /chosen */
-        dt_start_node(dt, "chosen");
-        dt_prop_str(dt, "bootargs", cmd_line);
-        if (cmd_mem_limit)
-                dt_prop_u64(dt, "linux,memory-limit", cmd_mem_limit);
-        dt_end_node(dt);
-
-        dt_cpus(dt);
-
-        dt_end_node(dt);
-
-        dt_push_u32(dt, OF_DT_END);
-}
-
 void * __init iSeries_early_setup(void)
 {
         unsigned long phys_mem_size;
@@ -965,28 +720,8 @@ void * __init iSeries_early_setup(void)
 
         iSeries_get_cmdline();
 
-        /* Save unparsed command line copy for /proc/cmdline */
-        strlcpy(saved_command_line, cmd_line, COMMAND_LINE_SIZE);
-
-        /* Parse early parameters, in particular mem=x */
-        parse_early_param();
-
-        build_flat_dt(&iseries_dt, phys_mem_size);
-
-        return (void *) __pa(&iseries_dt);
-}
-
-/*
- * On iSeries we just parse the mem=X option from the command line.
- * On pSeries it's a bit more complicated, see prom_init_mem()
- */
-static int __init early_parsemem(char *p)
-{
-        if (p)
-                cmd_mem_limit = ALIGN(memparse(p, &p), PAGE_SIZE);
-        return 0;
+        return (void *) __pa(build_flat_dt(phys_mem_size));
 }
-early_param("mem", early_parsemem);
 
 static void hvputc(char c)
 {
diff --git a/arch/powerpc/platforms/iseries/setup.h b/arch/powerpc/platforms/iseries/setup.h
index 5213044ec411..0a47ac53c959 100644
--- a/arch/powerpc/platforms/iseries/setup.h
+++ b/arch/powerpc/platforms/iseries/setup.h
@@ -21,4 +21,6 @@ extern unsigned long iSeries_get_boot_time(void);
 extern int iSeries_set_rtc_time(struct rtc_time *tm);
 extern void iSeries_get_rtc_time(struct rtc_time *tm);
 
+extern void *build_flat_dt(unsigned long phys_mem_size);
+
 #endif /* __ISERIES_SETUP_H__ */
diff --git a/arch/powerpc/platforms/iseries/vio.c b/arch/powerpc/platforms/iseries/vio.c
deleted file mode 100644
index ad36ab0639f0..000000000000
--- a/arch/powerpc/platforms/iseries/vio.c
+++ /dev/null
@@ -1,131 +0,0 @@
-/*
- * IBM PowerPC iSeries Virtual I/O Infrastructure Support.
- *
- *    Copyright (c) 2005 Stephen Rothwell, IBM Corp.
- *
- *      This program is free software; you can redistribute it and/or
- *      modify it under the terms of the GNU General Public License
- *      as published by the Free Software Foundation; either version
- *      2 of the License, or (at your option) any later version.
- */
-#include <linux/types.h>
-#include <linux/device.h>
-#include <linux/init.h>
-
-#include <asm/vio.h>
-#include <asm/iommu.h>
-#include <asm/tce.h>
-#include <asm/abs_addr.h>
-#include <asm/page.h>
-#include <asm/iseries/vio.h>
-#include <asm/iseries/hv_types.h>
-#include <asm/iseries/hv_lp_config.h>
-#include <asm/iseries/hv_call_xm.h>
-
-#include "iommu.h"
-
-struct device *iSeries_vio_dev = &vio_bus_device.dev;
-EXPORT_SYMBOL(iSeries_vio_dev);
-
-static struct iommu_table veth_iommu_table;
-static struct iommu_table vio_iommu_table;
-
-static void __init iommu_vio_init(void)
-{
-        iommu_table_getparms_iSeries(255, 0, 0xff, &veth_iommu_table);
-        veth_iommu_table.it_size /= 2;
-        vio_iommu_table = veth_iommu_table;
-        vio_iommu_table.it_offset += veth_iommu_table.it_size;
-
-        if (!iommu_init_table(&veth_iommu_table))
-                printk("Virtual Bus VETH TCE table failed.\n");
-        if (!iommu_init_table(&vio_iommu_table))
-                printk("Virtual Bus VIO TCE table failed.\n");
-}
-
-/**
- * vio_register_device_iseries: - Register a new iSeries vio device.
- * @voidev:     The device to register.
- */
-static struct vio_dev *__init vio_register_device_iseries(char *type,
-                uint32_t unit_num)
-{
-        struct vio_dev *viodev;
-
-        /* allocate a vio_dev for this device */
-        viodev = kmalloc(sizeof(struct vio_dev), GFP_KERNEL);
-        if (!viodev)
-                return NULL;
-        memset(viodev, 0, sizeof(struct vio_dev));
-
-        snprintf(viodev->dev.bus_id, BUS_ID_SIZE, "%s%d", type, unit_num);
-
-        viodev->name = viodev->dev.bus_id;
-        viodev->type = type;
-        viodev->unit_address = unit_num;
-        viodev->iommu_table = &vio_iommu_table;
-        if (vio_register_device(viodev) == NULL) {
-                kfree(viodev);
-                return NULL;
-        }
-        return viodev;
-}
-
-void __init probe_bus_iseries(void)
-{
-        HvLpIndexMap vlan_map;
-        struct vio_dev *viodev;
-        int i;
-
-        /* there is only one of each of these */
-        vio_register_device_iseries("viocons", 0);
-        vio_register_device_iseries("vscsi", 0);
-
-        vlan_map = HvLpConfig_getVirtualLanIndexMap();
-        for (i = 0; i < HVMAXARCHITECTEDVIRTUALLANS; i++) {
-                if ((vlan_map & (0x8000 >> i)) == 0)
-                        continue;
-                viodev = vio_register_device_iseries("vlan", i);
-                /* veth is special and has it own iommu_table */
-                viodev->iommu_table = &veth_iommu_table;
-        }
-        for (i = 0; i < HVMAXARCHITECTEDVIRTUALDISKS; i++)
-                vio_register_device_iseries("viodasd", i);
-        for (i = 0; i < HVMAXARCHITECTEDVIRTUALCDROMS; i++)
-                vio_register_device_iseries("viocd", i);
-        for (i = 0; i < HVMAXARCHITECTEDVIRTUALTAPES; i++)
-                vio_register_device_iseries("viotape", i);
-}
-
-/**
- * vio_match_device_iseries: - Tell if a iSeries VIO device matches a
- *      vio_device_id
- */
-static int vio_match_device_iseries(const struct vio_device_id *id,
-                const struct vio_dev *dev)
-{
-        return strncmp(dev->type, id->type, strlen(id->type)) == 0;
-}
-
-static struct vio_bus_ops vio_bus_ops_iseries = {
-        .match = vio_match_device_iseries,
-};
-
-/**
- * vio_bus_init_iseries: - Initialize the iSeries virtual IO bus
- */
-static int __init vio_bus_init_iseries(void)
-{
-        int err;
-
-        err = vio_bus_init(&vio_bus_ops_iseries);
-        if (err == 0) {
-                iommu_vio_init();
-                vio_bus_device.iommu_table = &vio_iommu_table;
-                iSeries_vio_dev = &vio_bus_device.dev;
-                probe_bus_iseries();
-        }
-        return err;
-}
-
-__initcall(vio_bus_init_iseries);
diff --git a/arch/powerpc/platforms/maple/pci.c b/arch/powerpc/platforms/maple/pci.c
index 85d6c93659cc..9a4efc0c3b29 100644
--- a/arch/powerpc/platforms/maple/pci.c
+++ b/arch/powerpc/platforms/maple/pci.c
@@ -437,9 +437,6 @@ void __init maple_pci_init(void)
 
         /* Tell pci.c to not change any resource allocations.  */
         pci_probe_only = 1;
-        
-        /* Allow all IO */
-        io_page_mask = -1;
 }
 
 int maple_pci_get_legacy_ide_irq(struct pci_dev *pdev, int channel)
diff --git a/arch/powerpc/platforms/maple/setup.c b/arch/powerpc/platforms/maple/setup.c
index 24c0aef4ea39..a0505ea48a86 100644
--- a/arch/powerpc/platforms/maple/setup.c
+++ b/arch/powerpc/platforms/maple/setup.c
@@ -189,7 +189,7 @@ void __init maple_setup_arch(void)
         conswitchp = &dummy_con;
 #endif
 
-        printk(KERN_INFO "Using native/NAP idle loop\n");
+        printk(KERN_DEBUG "Using native/NAP idle loop\n");
 }
 
 /* 
diff --git a/arch/powerpc/platforms/powermac/cpufreq_32.c b/arch/powerpc/platforms/powermac/cpufreq_32.c
index cfd6527a0d7e..af2a8f9f1222 100644
--- a/arch/powerpc/platforms/powermac/cpufreq_32.c
+++ b/arch/powerpc/platforms/powermac/cpufreq_32.c
@@ -314,7 +314,7 @@ static int pmu_set_cpu_speed(int low_speed)
                 _set_L3CR(save_l3cr);
 
         /* Restore userland MMU context */
-        set_context(current->active_mm->context, current->active_mm->pgd);
+        set_context(current->active_mm->context.id, current->active_mm->pgd);
 
 #ifdef DEBUG_FREQ
         printk(KERN_DEBUG "HID1, after: %x\n", mfspr(SPRN_HID1));
diff --git a/arch/powerpc/platforms/powermac/feature.c b/arch/powerpc/platforms/powermac/feature.c
index a5063cd675c5..85e00cb0006e 100644
--- a/arch/powerpc/platforms/powermac/feature.c
+++ b/arch/powerpc/platforms/powermac/feature.c
@@ -2510,7 +2510,7 @@ found:
                 if (get_property(np, "flush-on-lock", NULL))
                         break;
                 powersave_nap = 1;
-                printk(KERN_INFO "Processor NAP mode on idle enabled.\n");
+                printk(KERN_DEBUG "Processor NAP mode on idle enabled.\n");
                 break;
         }
 
diff --git a/arch/powerpc/platforms/powermac/pci.c b/arch/powerpc/platforms/powermac/pci.c
index ea179afea632..80035853467b 100644
--- a/arch/powerpc/platforms/powermac/pci.c
+++ b/arch/powerpc/platforms/powermac/pci.c
@@ -1068,9 +1068,6 @@ void __init pmac_pci_init(void)
         /* Tell pci.c to not use the common resource allocation mechanism */
         pci_probe_only = 1;
 
-        /* Allow all IO */
-        io_page_mask = -1;
-
 #else /* CONFIG_PPC64 */
         init_p2pbridge();
         fixup_nec_usb2();
diff --git a/arch/powerpc/platforms/powermac/pfunc_core.c b/arch/powerpc/platforms/powermac/pfunc_core.c
index f08173b0f065..047f954a89eb 100644
--- a/arch/powerpc/platforms/powermac/pfunc_core.c
+++ b/arch/powerpc/platforms/powermac/pfunc_core.c
@@ -871,10 +871,17 @@ int pmf_register_irq_client(struct device_node *target,
         spin_unlock_irqrestore(&pmf_lock, flags);
         if (func == NULL)
                 return -ENODEV;
+
+        /* guard against manipulations of list */
         mutex_lock(&pmf_irq_mutex);
         if (list_empty(&func->irq_clients))
                 func->dev->handlers->irq_enable(func);
+
+        /* guard against pmf_do_irq while changing list */
+        spin_lock_irqsave(&pmf_lock, flags);
         list_add(&client->link, &func->irq_clients);
+        spin_unlock_irqrestore(&pmf_lock, flags);
+
         client->func = func;
         mutex_unlock(&pmf_irq_mutex);
 
@@ -885,12 +892,19 @@ EXPORT_SYMBOL_GPL(pmf_register_irq_client);
 void pmf_unregister_irq_client(struct pmf_irq_client *client)
 {
         struct pmf_function *func = client->func;
+        unsigned long flags;
 
         BUG_ON(func == NULL);
 
+        /* guard against manipulations of list */
         mutex_lock(&pmf_irq_mutex);
         client->func = NULL;
+
+        /* guard against pmf_do_irq while changing list */
+        spin_lock_irqsave(&pmf_lock, flags);
         list_del(&client->link);
+        spin_unlock_irqrestore(&pmf_lock, flags);
+
         if (list_empty(&func->irq_clients))
                 func->dev->handlers->irq_disable(func);
         mutex_unlock(&pmf_irq_mutex);
diff --git a/arch/powerpc/platforms/powermac/setup.c b/arch/powerpc/platforms/powermac/setup.c
index b9200fb07815..9cc7db7a8bdc 100644
--- a/arch/powerpc/platforms/powermac/setup.c
+++ b/arch/powerpc/platforms/powermac/setup.c
@@ -458,7 +458,7 @@ 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);
+        set_context(current->active_mm->context.id, current->active_mm->pgd);
 
         return 0;
 }
diff --git a/arch/powerpc/platforms/pseries/Makefile b/arch/powerpc/platforms/pseries/Makefile
index 930898635c9f..e5e0ff466904 100644
--- a/arch/powerpc/platforms/pseries/Makefile
+++ b/arch/powerpc/platforms/pseries/Makefile
@@ -1,8 +1,11 @@
+ifeq ($(CONFIG_PPC64),y)
+EXTRA_CFLAGS            += -mno-minimal-toc
+endif
+
 obj-y                   := pci.o lpar.o hvCall.o nvram.o reconfig.o \
                            setup.o iommu.o ras.o rtasd.o pci_dlpar.o \
                            firmware.o
 obj-$(CONFIG_SMP)       += smp.o
-obj-$(CONFIG_IBMVIO)    += vio.o
 obj-$(CONFIG_XICS)      += xics.o
 obj-$(CONFIG_SCANLOG)   += scanlog.o
 obj-$(CONFIG_EEH)       += eeh.o eeh_cache.o eeh_driver.o eeh_event.o
diff --git a/arch/powerpc/platforms/pseries/eeh_cache.c b/arch/powerpc/platforms/pseries/eeh_cache.c
index d4a402c5866c..98c23aec85be 100644
--- a/arch/powerpc/platforms/pseries/eeh_cache.c
+++ b/arch/powerpc/platforms/pseries/eeh_cache.c
@@ -304,6 +304,8 @@ void __init pci_addr_cache_build(void)
                 pci_addr_cache_insert_device(dev);
 
                 dn = pci_device_to_OF_node(dev);
+                if (!dn)
+                        continue;
                 pci_dev_get (dev);  /* matching put is in eeh_remove_device() */
                 PCI_DN(dn)->pcidev = dev;
         }
diff --git a/arch/powerpc/platforms/pseries/eeh_driver.c b/arch/powerpc/platforms/pseries/eeh_driver.c
index 1fba695e32e8..0ec9a5445b95 100644
--- a/arch/powerpc/platforms/pseries/eeh_driver.c
+++ b/arch/powerpc/platforms/pseries/eeh_driver.c
@@ -23,9 +23,8 @@
  *
  */
 #include <linux/delay.h>
-#include <linux/irq.h>
 #include <linux/interrupt.h>
-#include <linux/notifier.h>
+#include <linux/irq.h>
 #include <linux/pci.h>
 #include <asm/eeh.h>
 #include <asm/eeh_event.h>
@@ -202,7 +201,11 @@ static void eeh_report_failure(struct pci_dev *dev, void *userdata)
 
 static int eeh_reset_device (struct pci_dn *pe_dn, struct pci_bus *bus)
 {
-        int rc;
+        int cnt, rc;
+
+        /* pcibios will clear the counter; save the value */
+        cnt = pe_dn->eeh_freeze_count;
+
         if (bus)
                 pcibios_remove_pci_devices(bus);
 
@@ -241,6 +244,7 @@ static int eeh_reset_device (struct pci_dn *pe_dn, struct pci_bus *bus)
                 ssleep (5);
                 pcibios_add_pci_devices(bus);
         }
+        pe_dn->eeh_freeze_count = cnt;
 
         return 0;
 }
@@ -250,23 +254,29 @@ static int eeh_reset_device (struct pci_dn *pe_dn, struct pci_bus *bus)
  */
 #define MAX_WAIT_FOR_RECOVERY 15
 
-void handle_eeh_events (struct eeh_event *event)
+struct pci_dn * handle_eeh_events (struct eeh_event *event)
 {
         struct device_node *frozen_dn;
         struct pci_dn *frozen_pdn;
         struct pci_bus *frozen_bus;
         int rc = 0;
         enum pci_ers_result result = PCI_ERS_RESULT_NONE;
-        const char *pci_str, *drv_str;
+        const char *location, *pci_str, *drv_str;
 
         frozen_dn = find_device_pe(event->dn);
         frozen_bus = pcibios_find_pci_bus(frozen_dn);
 
         if (!frozen_dn) {
-                printk(KERN_ERR "EEH: Error: Cannot find partition endpoint for %s\n",
-                        pci_name(event->dev));
-                return;
+
+                location = (char *) get_property(event->dn, "ibm,loc-code", NULL);
+                location = location ? location : "unknown";
+                printk(KERN_ERR "EEH: Error: Cannot find partition endpoint "
+                                "for location=%s pci addr=%s\n",
+                        location, pci_name(event->dev));
+                return NULL;
         }
+        location = (char *) get_property(frozen_dn, "ibm,loc-code", NULL);
+        location = location ? location : "unknown";
 
         /* There are two different styles for coming up with the PE.
          * In the old style, it was the highest EEH-capable device
@@ -278,9 +288,10 @@ void handle_eeh_events (struct eeh_event *event)
                 frozen_bus = pcibios_find_pci_bus (frozen_dn->parent);
 
         if (!frozen_bus) {
-                printk(KERN_ERR "EEH: Cannot find PCI bus for %s\n",
-                        frozen_dn->full_name);
-                return;
+                printk(KERN_ERR "EEH: Cannot find PCI bus "
+                        "for location=%s dn=%s\n",
+                        location, frozen_dn->full_name);
+                return NULL;
         }
 
 #if 0
@@ -314,8 +325,9 @@ void handle_eeh_events (struct eeh_event *event)
 
         eeh_slot_error_detail(frozen_pdn, 1 /* Temporary Error */);
         printk(KERN_WARNING
-           "EEH: This PCI device has failed %d times since last reboot: %s - %s\n",
-                frozen_pdn->eeh_freeze_count, drv_str, pci_str);
+           "EEH: This PCI device has failed %d times since last reboot: "
+                "location=%s driver=%s pci addr=%s\n",
+                frozen_pdn->eeh_freeze_count, location, drv_str, pci_str);
 
         /* Walk the various device drivers attached to this slot through
          * a reset sequence, giving each an opportunity to do what it needs
@@ -355,7 +367,7 @@ void handle_eeh_events (struct eeh_event *event)
         /* Tell all device drivers that they can resume operations */
         pci_walk_bus(frozen_bus, eeh_report_resume, NULL);
 
-        return;
+        return frozen_pdn;
         
 excess_failures:
         /*
@@ -364,17 +376,18 @@ excess_failures:
          * due to actual, failed cards.
          */
         printk(KERN_ERR
-           "EEH: PCI device %s - %s has failed %d times \n"
-           "and has been permanently disabled.  Please try reseating\n"
-           "this device or replacing it.\n",
-                drv_str, pci_str, frozen_pdn->eeh_freeze_count);
+           "EEH: PCI device at location=%s driver=%s pci addr=%s \n"
+                "has failed %d times and has been permanently disabled. \n"
+                "Please try reseating this device or replacing it.\n",
+                location, drv_str, pci_str, frozen_pdn->eeh_freeze_count);
         goto perm_error;
 
 hard_fail:
         printk(KERN_ERR
-           "EEH: Unable to recover from failure of PCI device %s - %s\n"
+           "EEH: Unable to recover from failure of PCI device "
+           "at location=%s driver=%s pci addr=%s \n"
            "Please try reseating this device or replacing it.\n",
-                drv_str, pci_str);
+                location, drv_str, pci_str);
 
 perm_error:
         eeh_slot_error_detail(frozen_pdn, 2 /* Permanent Error */);
@@ -384,6 +397,8 @@ perm_error:
 
         /* Shut down the device drivers for good. */
         pcibios_remove_pci_devices(frozen_bus);
+
+        return NULL;
 }
 
 /* ---------- end of file ---------- */
diff --git a/arch/powerpc/platforms/pseries/eeh_event.c b/arch/powerpc/platforms/pseries/eeh_event.c
index 40020c65c89e..8f2d12935b99 100644
--- a/arch/powerpc/platforms/pseries/eeh_event.c
+++ b/arch/powerpc/platforms/pseries/eeh_event.c
@@ -18,6 +18,7 @@
  * Copyright (c) 2005 Linas Vepstas <linas@linas.org>
  */
 
+#include <linux/delay.h>
 #include <linux/list.h>
 #include <linux/mutex.h>
 #include <linux/pci.h>
@@ -56,38 +57,43 @@ static int eeh_event_handler(void * dummy)
 {
         unsigned long flags;
         struct eeh_event        *event;
+        struct pci_dn *pdn;
 
         daemonize ("eehd");
+        set_current_state(TASK_INTERRUPTIBLE);
 
-        while (1) {
-                set_current_state(TASK_INTERRUPTIBLE);
+        spin_lock_irqsave(&eeh_eventlist_lock, flags);
+        event = NULL;
 
-                spin_lock_irqsave(&eeh_eventlist_lock, flags);
-                event = NULL;
+        /* Unqueue the event, get ready to process. */
+        if (!list_empty(&eeh_eventlist)) {
+                event = list_entry(eeh_eventlist.next, struct eeh_event, list);
+                list_del(&event->list);
+        }
+        spin_unlock_irqrestore(&eeh_eventlist_lock, flags);
 
-                /* Unqueue the event, get ready to process. */
-                if (!list_empty(&eeh_eventlist)) {
-                        event = list_entry(eeh_eventlist.next, struct eeh_event, list);
-                        list_del(&event->list);
-                }
-                spin_unlock_irqrestore(&eeh_eventlist_lock, flags);
+        if (event == NULL)
+                return 0;
 
-                if (event == NULL)
-                        break;
+        /* Serialize processing of EEH events */
+        mutex_lock(&eeh_event_mutex);
+        eeh_mark_slot(event->dn, EEH_MODE_RECOVERING);
 
-                /* Serialize processing of EEH events */
-                mutex_lock(&eeh_event_mutex);
-                eeh_mark_slot(event->dn, EEH_MODE_RECOVERING);
+        printk(KERN_INFO "EEH: Detected PCI bus error on device %s\n",
+               pci_name(event->dev));
 
-                printk(KERN_INFO "EEH: Detected PCI bus error on device %s\n",
-                       pci_name(event->dev));
+        pdn = handle_eeh_events(event);
 
-                handle_eeh_events(event);
+        eeh_clear_slot(event->dn, EEH_MODE_RECOVERING);
+        pci_dev_put(event->dev);
+        kfree(event);
+        mutex_unlock(&eeh_event_mutex);
 
-                eeh_clear_slot(event->dn, EEH_MODE_RECOVERING);
-                pci_dev_put(event->dev);
-                kfree(event);
-                mutex_unlock(&eeh_event_mutex);
+        /* If there are no new errors after an hour, clear the counter. */
+        if (pdn && pdn->eeh_freeze_count>0) {
+                msleep_interruptible (3600*1000);
+                if (pdn->eeh_freeze_count>0)
+                        pdn->eeh_freeze_count--;
         }
 
         return 0;
diff --git a/arch/powerpc/platforms/pseries/iommu.c b/arch/powerpc/platforms/pseries/iommu.c
index 2643078433f0..d03a8b078f9d 100644
--- a/arch/powerpc/platforms/pseries/iommu.c
+++ b/arch/powerpc/platforms/pseries/iommu.c
@@ -1,23 +1,24 @@
 /*
  * Copyright (C) 2001 Mike Corrigan & Dave Engebretsen, IBM Corporation
  *
- * Rewrite, cleanup: 
+ * Rewrite, cleanup:
  *
  * Copyright (C) 2004 Olof Johansson <olof@lixom.net>, IBM Corporation
+ * Copyright (C) 2006 Olof Johansson <olof@lixom.net>
  *
  * Dynamic DMA mapping support, pSeries-specific parts, both SMP and LPAR.
  *
- * 
+ *
  * 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
@@ -49,52 +50,46 @@
 
 #define DBG(fmt...)
 
-static void tce_build_pSeries(struct iommu_table *tbl, long index, 
-                              long npages, unsigned long uaddr, 
+static void tce_build_pSeries(struct iommu_table *tbl, long index,
+                              long npages, unsigned long uaddr,
                               enum dma_data_direction direction)
 {
-        union tce_entry t;
-        union tce_entry *tp;
+        u64 proto_tce;
+        u64 *tcep;
+        u64 rpn;
 
         index <<= TCE_PAGE_FACTOR;
         npages <<= TCE_PAGE_FACTOR;
 
-        t.te_word = 0;
-        t.te_rdwr = 1; // Read allowed 
+        proto_tce = TCE_PCI_READ; // Read allowed
 
         if (direction != DMA_TO_DEVICE)
-                t.te_pciwr = 1;
+                proto_tce |= TCE_PCI_WRITE;
 
-        tp = ((union tce_entry *)tbl->it_base) + index;
+        tcep = ((u64 *)tbl->it_base) + index;
 
         while (npages--) {
                 /* can't move this out since we might cross LMB boundary */
-                t.te_rpn = (virt_to_abs(uaddr)) >> TCE_SHIFT;
-        
-                tp->te_word = t.te_word;
+                rpn = (virt_to_abs(uaddr)) >> TCE_SHIFT;
+                *tcep = proto_tce | (rpn & TCE_RPN_MASK) << TCE_RPN_SHIFT;
 
                 uaddr += TCE_PAGE_SIZE;
-                tp++;
+                tcep++;
         }
 }
 
 
 static void tce_free_pSeries(struct iommu_table *tbl, long index, long npages)
 {
-        union tce_entry t;
-        union tce_entry *tp;
+        u64 *tcep;
 
         npages <<= TCE_PAGE_FACTOR;
         index <<= TCE_PAGE_FACTOR;
 
-        t.te_word = 0;
-        tp  = ((union tce_entry *)tbl->it_base) + index;
-                
-        while (npages--) {
-                tp->te_word = t.te_word;
-                
-                tp++;
-        }
+        tcep = ((u64 *)tbl->it_base) + index;
+
+        while (npages--)
+                *(tcep++) = 0;
 }
 
 
@@ -103,43 +98,44 @@ static void tce_build_pSeriesLP(struct iommu_table *tbl, long tcenum,
                                 enum dma_data_direction direction)
 {
         u64 rc;
-        union tce_entry tce;
+        u64 proto_tce, tce;
+        u64 rpn;
 
         tcenum <<= TCE_PAGE_FACTOR;
         npages <<= TCE_PAGE_FACTOR;
 
-        tce.te_word = 0;
-        tce.te_rpn = (virt_to_abs(uaddr)) >> TCE_SHIFT;
-        tce.te_rdwr = 1;
+        rpn = (virt_to_abs(uaddr)) >> TCE_SHIFT;
+        proto_tce = TCE_PCI_READ;
         if (direction != DMA_TO_DEVICE)
-                tce.te_pciwr = 1;
+                proto_tce |= TCE_PCI_WRITE;
 
         while (npages--) {
-                rc = plpar_tce_put((u64)tbl->it_index, 
-                                   (u64)tcenum << 12, 
-                                   tce.te_word );
-                
+                tce = proto_tce | (rpn & TCE_RPN_MASK) << TCE_RPN_SHIFT;
+                rc = plpar_tce_put((u64)tbl->it_index, (u64)tcenum << 12, tce);
+
                 if (rc && printk_ratelimit()) {
                         printk("tce_build_pSeriesLP: plpar_tce_put failed. rc=%ld\n", rc);
                         printk("\tindex   = 0x%lx\n", (u64)tbl->it_index);
                         printk("\ttcenum  = 0x%lx\n", (u64)tcenum);
-                        printk("\ttce val = 0x%lx\n", tce.te_word );
+                        printk("\ttce val = 0x%lx\n", tce );
                         show_stack(current, (unsigned long *)__get_SP());
                 }
-                        
+
                 tcenum++;
-                tce.te_rpn++;
+                rpn++;
         }
 }
 
-static DEFINE_PER_CPU(void *, tce_page) = NULL;
+static DEFINE_PER_CPU(u64 *, tce_page) = NULL;
 
 static void tce_buildmulti_pSeriesLP(struct iommu_table *tbl, long tcenum,
                                      long npages, unsigned long uaddr,
                                      enum dma_data_direction direction)
 {
         u64 rc;
-        union tce_entry tce, *tcep;
+        u64 proto_tce;
+        u64 *tcep;
+        u64 rpn;
         long l, limit;
 
         if (TCE_PAGE_FACTOR == 0 && npages == 1)
@@ -152,7 +148,7 @@ static void tce_buildmulti_pSeriesLP(struct iommu_table *tbl, long tcenum,
          * from iommu_alloc{,_sg}()
          */
         if (!tcep) {
-                tcep = (void *)__get_free_page(GFP_ATOMIC);
+                tcep = (u64 *)__get_free_page(GFP_ATOMIC);
                 /* If allocation fails, fall back to the loop implementation */
                 if (!tcep)
                         return tce_build_pSeriesLP(tbl, tcenum, npages,
@@ -163,11 +159,10 @@ static void tce_buildmulti_pSeriesLP(struct iommu_table *tbl, long tcenum,
         tcenum <<= TCE_PAGE_FACTOR;
         npages <<= TCE_PAGE_FACTOR;
 
-        tce.te_word = 0;
-        tce.te_rpn = (virt_to_abs(uaddr)) >> TCE_SHIFT;
-        tce.te_rdwr = 1;
+        rpn = (virt_to_abs(uaddr)) >> TCE_SHIFT;
+        proto_tce = TCE_PCI_READ;
         if (direction != DMA_TO_DEVICE)
-                tce.te_pciwr = 1;
+                proto_tce |= TCE_PCI_WRITE;
 
         /* We can map max one pageful of TCEs at a time */
         do {
@@ -175,11 +170,11 @@ static void tce_buildmulti_pSeriesLP(struct iommu_table *tbl, long tcenum,
                  * Set up the page with TCE data, looping through and setting
                  * the values.
                  */
-                limit = min_t(long, npages, 4096/sizeof(union tce_entry));
+                limit = min_t(long, npages, 4096/TCE_ENTRY_SIZE);
 
                 for (l = 0; l < limit; l++) {
-                        tcep[l] = tce;
-                        tce.te_rpn++;
+                        tcep[l] = proto_tce | (rpn & TCE_RPN_MASK) << TCE_RPN_SHIFT;
+                        rpn++;
                 }
 
                 rc = plpar_tce_put_indirect((u64)tbl->it_index,
@@ -195,7 +190,7 @@ static void tce_buildmulti_pSeriesLP(struct iommu_table *tbl, long tcenum,
                 printk("tce_buildmulti_pSeriesLP: plpar_tce_put failed. rc=%ld\n", rc);
                 printk("\tindex   = 0x%lx\n", (u64)tbl->it_index);
                 printk("\tnpages  = 0x%lx\n", (u64)npages);
-                printk("\ttce[0] val = 0x%lx\n", tcep[0].te_word);
+                printk("\ttce[0] val = 0x%lx\n", tcep[0]);
                 show_stack(current, (unsigned long *)__get_SP());
         }
 }
@@ -203,23 +198,17 @@ static void tce_buildmulti_pSeriesLP(struct iommu_table *tbl, long tcenum,
 static void tce_free_pSeriesLP(struct iommu_table *tbl, long tcenum, long npages)
 {
         u64 rc;
-        union tce_entry tce;
 
         tcenum <<= TCE_PAGE_FACTOR;
         npages <<= TCE_PAGE_FACTOR;
 
-        tce.te_word = 0;
-
         while (npages--) {
-                rc = plpar_tce_put((u64)tbl->it_index,
-                                   (u64)tcenum << 12,
-                                   tce.te_word);
+                rc = plpar_tce_put((u64)tbl->it_index, (u64)tcenum << 12, 0);
 
                 if (rc && printk_ratelimit()) {
                         printk("tce_free_pSeriesLP: plpar_tce_put failed. rc=%ld\n", rc);
                         printk("\tindex   = 0x%lx\n", (u64)tbl->it_index);
                         printk("\ttcenum  = 0x%lx\n", (u64)tcenum);
-                        printk("\ttce val = 0x%lx\n", tce.te_word );
                         show_stack(current, (unsigned long *)__get_SP());
                 }
 
@@ -231,31 +220,24 @@ static void tce_free_pSeriesLP(struct iommu_table *tbl, long tcenum, long npages
 static void tce_freemulti_pSeriesLP(struct iommu_table *tbl, long tcenum, long npages)
 {
         u64 rc;
-        union tce_entry tce;
 
         tcenum <<= TCE_PAGE_FACTOR;
         npages <<= TCE_PAGE_FACTOR;
 
-        tce.te_word = 0;
-
-        rc = plpar_tce_stuff((u64)tbl->it_index,
-                           (u64)tcenum << 12,
-                           tce.te_word,
-                           npages);
+        rc = plpar_tce_stuff((u64)tbl->it_index, (u64)tcenum << 12, 0, npages);
 
         if (rc && printk_ratelimit()) {
                 printk("tce_freemulti_pSeriesLP: plpar_tce_stuff failed\n");
                 printk("\trc      = %ld\n", rc);
                 printk("\tindex   = 0x%lx\n", (u64)tbl->it_index);
                 printk("\tnpages  = 0x%lx\n", (u64)npages);
-                printk("\ttce val = 0x%lx\n", tce.te_word );
                 show_stack(current, (unsigned long *)__get_SP());
         }
 }
 
 static void iommu_table_setparms(struct pci_controller *phb,
                                  struct device_node *dn,
-                                 struct iommu_table *tbl) 
+                                 struct iommu_table *tbl)
 {
         struct device_node *node;
         unsigned long *basep;
@@ -275,16 +257,16 @@ static void iommu_table_setparms(struct pci_controller *phb,
         memset((void *)tbl->it_base, 0, *sizep);
 
         tbl->it_busno = phb->bus->number;
-        
+
         /* Units of tce entries */
         tbl->it_offset = phb->dma_window_base_cur >> PAGE_SHIFT;
-        
+
         /* Test if we are going over 2GB of DMA space */
         if (phb->dma_window_base_cur + phb->dma_window_size > 0x80000000ul) {
                 udbg_printf("PCI_DMA: Unexpected number of IOAs under this PHB.\n");
-                panic("PCI_DMA: Unexpected number of IOAs under this PHB.\n"); 
+                panic("PCI_DMA: Unexpected number of IOAs under this PHB.\n");
         }
-        
+
         phb->dma_window_base_cur += phb->dma_window_size;
 
         /* Set the tce table size - measured in entries */
@@ -299,30 +281,22 @@ static void iommu_table_setparms(struct pci_controller *phb,
  * iommu_table_setparms_lpar
  *
  * Function: On pSeries LPAR systems, return TCE table info, given a pci bus.
- *
- * ToDo: properly interpret the ibm,dma-window property.  The definition is:
- *      logical-bus-number      (1 word)
- *      phys-address            (#address-cells words)
- *      size                    (#cell-size words)
- *
- * Currently we hard code these sizes (more or less).
  */
 static void iommu_table_setparms_lpar(struct pci_controller *phb,
                                       struct device_node *dn,
                                       struct iommu_table *tbl,
-                                      unsigned int *dma_window)
+                                      unsigned char *dma_window)
 {
+        unsigned long offset, size;
+
         tbl->it_busno  = PCI_DN(dn)->bussubno;
+        of_parse_dma_window(dn, dma_window, &tbl->it_index, &offset, &size);
 
-        /* TODO: Parse field size properties properly. */
-        tbl->it_size   = (((unsigned long)dma_window[4] << 32) |
-                           (unsigned long)dma_window[5]) >> PAGE_SHIFT;
-        tbl->it_offset = (((unsigned long)dma_window[2] << 32) |
-                           (unsigned long)dma_window[3]) >> PAGE_SHIFT;
         tbl->it_base   = 0;
-        tbl->it_index  = dma_window[0];
         tbl->it_blocksize  = 16;
         tbl->it_type = TCE_PCI;
+        tbl->it_offset = offset >> PAGE_SHIFT;
+        tbl->it_size = size >> PAGE_SHIFT;
 }
 
 static void iommu_bus_setup_pSeries(struct pci_bus *bus)
@@ -357,13 +331,9 @@ static void iommu_bus_setup_pSeries(struct pci_bus *bus)
         if (isa_dn_orig)
                 of_node_put(isa_dn_orig);
 
-        /* Count number of direct PCI children of the PHB.
-         * All PCI device nodes have class-code property, so it's
-         * an easy way to find them.
-         */
+        /* Count number of direct PCI children of the PHB. */
         for (children = 0, tmp = dn->child; tmp; tmp = tmp->sibling)
-                if (get_property(tmp, "class-code", NULL))
-                        children++;
+                children++;
 
         DBG("Children: %d\n", children);
 
@@ -394,10 +364,11 @@ static void iommu_bus_setup_pSeries(struct pci_bus *bus)
         pci->phb->dma_window_size = 0x8000000ul;
         pci->phb->dma_window_base_cur = 0x8000000ul;
 
-        tbl = kmalloc(sizeof(struct iommu_table), GFP_KERNEL);
+        tbl = kmalloc_node(sizeof(struct iommu_table), GFP_KERNEL,
+                           pci->phb->node);
 
         iommu_table_setparms(pci->phb, dn, tbl);
-        pci->iommu_table = iommu_init_table(tbl);
+        pci->iommu_table = iommu_init_table(tbl, pci->phb->node);
 
         /* Divide the rest (1.75GB) among the children */
         pci->phb->dma_window_size = 0x80000000ul;
@@ -414,7 +385,7 @@ static void iommu_bus_setup_pSeriesLP(struct pci_bus *bus)
         struct iommu_table *tbl;
         struct device_node *dn, *pdn;
         struct pci_dn *ppci;
-        unsigned int *dma_window = NULL;
+        unsigned char *dma_window = NULL;
 
         DBG("iommu_bus_setup_pSeriesLP, bus %p, bus->self %p\n", bus, bus->self);
 
@@ -422,7 +393,7 @@ static void iommu_bus_setup_pSeriesLP(struct pci_bus *bus)
 
         /* Find nearest ibm,dma-window, walking up the device tree */
         for (pdn = dn; pdn != NULL; pdn = pdn->parent) {
-                dma_window = (unsigned int *)get_property(pdn, "ibm,dma-window", NULL);
+                dma_window = get_property(pdn, "ibm,dma-window", NULL);
                 if (dma_window != NULL)
                         break;
         }
@@ -440,12 +411,12 @@ static void iommu_bus_setup_pSeriesLP(struct pci_bus *bus)
 
                 ppci->bussubno = bus->number;
 
-                tbl = (struct iommu_table *)kmalloc(sizeof(struct iommu_table),
-                                                    GFP_KERNEL);
-        
+                tbl = kmalloc_node(sizeof(struct iommu_table), GFP_KERNEL,
+                                   ppci->phb->node);
+
                 iommu_table_setparms_lpar(ppci->phb, pdn, tbl, dma_window);
 
-                ppci->iommu_table = iommu_init_table(tbl);
+                ppci->iommu_table = iommu_init_table(tbl, ppci->phb->node);
         }
 
         if (pdn != dn)
@@ -468,9 +439,11 @@ static void iommu_dev_setup_pSeries(struct pci_dev *dev)
          */
         if (!dev->bus->self) {
                 DBG(" --> first child, no bridge. Allocating iommu table.\n");
-                tbl = kmalloc(sizeof(struct iommu_table), GFP_KERNEL);
+                tbl = kmalloc_node(sizeof(struct iommu_table), GFP_KERNEL,
+                                   PCI_DN(dn)->phb->node);
                 iommu_table_setparms(PCI_DN(dn)->phb, dn, tbl);
-                PCI_DN(mydn)->iommu_table = iommu_init_table(tbl);
+                PCI_DN(dn)->iommu_table = iommu_init_table(tbl,
+                                                PCI_DN(dn)->phb->node);
 
                 return;
         }
@@ -516,7 +489,7 @@ static void iommu_dev_setup_pSeriesLP(struct pci_dev *dev)
 {
         struct device_node *pdn, *dn;
         struct iommu_table *tbl;
-        int *dma_window = NULL;
+        unsigned char *dma_window = NULL;
         struct pci_dn *pci;
 
         DBG("iommu_dev_setup_pSeriesLP, dev %p (%s)\n", dev, pci_name(dev));
@@ -531,8 +504,7 @@ static void iommu_dev_setup_pSeriesLP(struct pci_dev *dev)
 
         for (pdn = dn; pdn && PCI_DN(pdn) && !PCI_DN(pdn)->iommu_table;
              pdn = pdn->parent) {
-                dma_window = (unsigned int *)
-                        get_property(pdn, "ibm,dma-window", NULL);
+                dma_window = get_property(pdn, "ibm,dma-window", NULL);
                 if (dma_window)
                         break;
         }
@@ -553,12 +525,12 @@ static void iommu_dev_setup_pSeriesLP(struct pci_dev *dev)
                 /* iommu_table_setparms_lpar needs bussubno. */
                 pci->bussubno = pci->phb->bus->number;
 
-                tbl = (struct iommu_table *)kmalloc(sizeof(struct iommu_table),
-                                                    GFP_KERNEL);
+                tbl = kmalloc_node(sizeof(struct iommu_table), GFP_KERNEL,
+                                   pci->phb->node);
 
                 iommu_table_setparms_lpar(pci->phb, pdn, tbl, dma_window);
 
-                pci->iommu_table = iommu_init_table(tbl);
+                pci->iommu_table = iommu_init_table(tbl, pci->phb->node);
         }
 
         if (pdn != dn)
diff --git a/arch/powerpc/platforms/pseries/rtasd.c b/arch/powerpc/platforms/pseries/rtasd.c
index e0000ce769e5..2e4e04042d85 100644
--- a/arch/powerpc/platforms/pseries/rtasd.c
+++ b/arch/powerpc/platforms/pseries/rtasd.c
@@ -348,7 +348,7 @@ static int enable_surveillance(int timeout)
                 return 0;
 
         if (error == -EINVAL) {
-                printk(KERN_INFO "rtasd: surveillance not supported\n");
+                printk(KERN_DEBUG "rtasd: surveillance not supported\n");
                 return 0;
         }
 
@@ -440,7 +440,7 @@ static int rtasd(void *unused)
                 goto error;
         }
 
-        printk(KERN_INFO "RTAS daemon started\n");
+        printk(KERN_DEBUG "RTAS daemon started\n");
 
         DEBUG("will sleep for %d milliseconds\n", (30000/rtas_event_scan_rate));
 
@@ -487,7 +487,7 @@ static int __init rtas_init(void)
 
         /* No RTAS */
         if (rtas_token("event-scan") == RTAS_UNKNOWN_SERVICE) {
-                printk(KERN_INFO "rtasd: no event-scan on system\n");
+                printk(KERN_DEBUG "rtasd: no event-scan on system\n");
                 return -ENODEV;
         }
 
diff --git a/arch/powerpc/platforms/pseries/scanlog.c b/arch/powerpc/platforms/pseries/scanlog.c
index 50643496eb63..77a5bb1d9c30 100644
--- a/arch/powerpc/platforms/pseries/scanlog.c
+++ b/arch/powerpc/platforms/pseries/scanlog.c
@@ -107,9 +107,9 @@ static ssize_t scanlog_read(struct file *file, char __user *buf,
                         /* Break to sleep default time */
                         break;
                     default:
-                        if (status > 9900 && status <= 9905) {
-                                wait_time = rtas_extended_busy_delay_time(status);
-                        } else {
+                        /* Assume extended busy */
+                        wait_time = rtas_busy_delay_time(status);
+                        if (!wait_time) {
                                 printk(KERN_ERR "scanlog: unknown error from rtas: %d\n", status);
                                 return -EIO;
                         }
diff --git a/arch/powerpc/platforms/pseries/setup.c b/arch/powerpc/platforms/pseries/setup.c
index 3ba87835757e..1e28518c6121 100644
--- a/arch/powerpc/platforms/pseries/setup.c
+++ b/arch/powerpc/platforms/pseries/setup.c
@@ -235,14 +235,14 @@ static void __init pSeries_setup_arch(void)
         if (firmware_has_feature(FW_FEATURE_SPLPAR)) {
                 vpa_init(boot_cpuid);
                 if (get_lppaca()->shared_proc) {
-                        printk(KERN_INFO "Using shared processor idle loop\n");
+                        printk(KERN_DEBUG "Using shared processor idle loop\n");
                         ppc_md.power_save = pseries_shared_idle_sleep;
                 } else {
-                        printk(KERN_INFO "Using dedicated idle loop\n");
+                        printk(KERN_DEBUG "Using dedicated idle loop\n");
                         ppc_md.power_save = pseries_dedicated_idle_sleep;
                 }
         } else {
-                printk(KERN_INFO "Using default idle loop\n");
+                printk(KERN_DEBUG "Using default idle loop\n");
         }
 
         if (firmware_has_feature(FW_FEATURE_LPAR))
diff --git a/arch/powerpc/platforms/pseries/vio.c b/arch/powerpc/platforms/pseries/vio.c
deleted file mode 100644
index 8e53e04ada8b..000000000000
--- a/arch/powerpc/platforms/pseries/vio.c
+++ /dev/null
@@ -1,274 +0,0 @@
-/*
- * IBM PowerPC pSeries Virtual I/O Infrastructure Support.
- *
- *    Copyright (c) 2003-2005 IBM Corp.
- *     Dave Engebretsen engebret@us.ibm.com
- *     Santiago Leon santil@us.ibm.com
- *     Hollis Blanchard <hollisb@us.ibm.com>
- *     Stephen Rothwell
- *
- *      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/init.h>
-#include <linux/module.h>
-#include <linux/mm.h>
-#include <linux/kobject.h>
-#include <asm/iommu.h>
-#include <asm/dma.h>
-#include <asm/prom.h>
-#include <asm/vio.h>
-#include <asm/hvcall.h>
-#include <asm/tce.h>
-
-extern struct subsystem devices_subsys; /* needed for vio_find_name() */
-
-static void probe_bus_pseries(void)
-{
-        struct device_node *node_vroot, *of_node;
-
-        node_vroot = find_devices("vdevice");
-        if ((node_vroot == NULL) || (node_vroot->child == NULL))
-                /* this machine doesn't do virtual IO, and that's ok */
-                return;
-
-        /*
-         * Create struct vio_devices for each virtual device in the device tree.
-         * Drivers will associate with them later.
-         */
-        for (of_node = node_vroot->child; of_node != NULL;
-                        of_node = of_node->sibling) {
-                printk(KERN_DEBUG "%s: processing %p\n", __FUNCTION__, of_node);
-                vio_register_device_node(of_node);
-        }
-}
-
-/**
- * vio_match_device_pseries: - Tell if a pSeries VIO device matches a
- *      vio_device_id
- */
-static int vio_match_device_pseries(const struct vio_device_id *id,
-                const struct vio_dev *dev)
-{
-        return (strncmp(dev->type, id->type, strlen(id->type)) == 0) &&
-                        device_is_compatible(dev->dev.platform_data, id->compat);
-}
-
-static void vio_release_device_pseries(struct device *dev)
-{
-        /* XXX free TCE table */
-        of_node_put(dev->platform_data);
-}
-
-static ssize_t viodev_show_devspec(struct device *dev,
-                struct device_attribute *attr, char *buf)
-{
-        struct device_node *of_node = dev->platform_data;
-
-        return sprintf(buf, "%s\n", of_node->full_name);
-}
-DEVICE_ATTR(devspec, S_IRUSR | S_IRGRP | S_IROTH, viodev_show_devspec, NULL);
-
-static void vio_unregister_device_pseries(struct vio_dev *viodev)
-{
-        device_remove_file(&viodev->dev, &dev_attr_devspec);
-}
-
-static struct vio_bus_ops vio_bus_ops_pseries = {
-        .match = vio_match_device_pseries,
-        .unregister_device = vio_unregister_device_pseries,
-        .release_device = vio_release_device_pseries,
-};
-
-/**
- * vio_bus_init_pseries: - Initialize the pSeries virtual IO bus
- */
-static int __init vio_bus_init_pseries(void)
-{
-        int err;
-
-        err = vio_bus_init(&vio_bus_ops_pseries);
-        if (err == 0)
-                probe_bus_pseries();
-        return err;
-}
-
-__initcall(vio_bus_init_pseries);
-
-/**
- * vio_build_iommu_table: - gets the dma information from OF and
- *      builds the TCE tree.
- * @dev: the virtual device.
- *
- * Returns a pointer to the built tce tree, or NULL if it can't
- * find property.
-*/
-static struct iommu_table *vio_build_iommu_table(struct vio_dev *dev)
-{
-        unsigned int *dma_window;
-        struct iommu_table *newTceTable;
-        unsigned long offset;
-        int dma_window_property_size;
-
-        dma_window = (unsigned int *) get_property(dev->dev.platform_data, "ibm,my-dma-window", &dma_window_property_size);
-        if(!dma_window) {
-                return NULL;
-        }
-
-        newTceTable = (struct iommu_table *) kmalloc(sizeof(struct iommu_table), GFP_KERNEL);
-
-        /*  There should be some code to extract the phys-encoded offset
-                using prom_n_addr_cells(). However, according to a comment
-                on earlier versions, it's always zero, so we don't bother */
-        offset = dma_window[1] >>  PAGE_SHIFT;
-
-        /* TCE table size - measured in tce entries */
-        newTceTable->it_size            = dma_window[4] >> PAGE_SHIFT;
-        /* offset for VIO should always be 0 */
-        newTceTable->it_offset          = offset;
-        newTceTable->it_busno           = 0;
-        newTceTable->it_index           = (unsigned long)dma_window[0];
-        newTceTable->it_type            = TCE_VB;
-
-        return iommu_init_table(newTceTable);
-}
-
-/**
- * vio_register_device_node: - Register a new vio device.
- * @of_node:    The OF node for this device.
- *
- * Creates and initializes a vio_dev structure from the data in
- * of_node (dev.platform_data) and adds it to the list of virtual devices.
- * Returns a pointer to the created vio_dev or NULL if node has
- * NULL device_type or compatible fields.
- */
-struct vio_dev * __devinit vio_register_device_node(struct device_node *of_node)
-{
-        struct vio_dev *viodev;
-        unsigned int *unit_address;
-        unsigned int *irq_p;
-
-        /* we need the 'device_type' property, in order to match with drivers */
-        if ((NULL == of_node->type)) {
-                printk(KERN_WARNING
-                        "%s: node %s missing 'device_type'\n", __FUNCTION__,
-                        of_node->name ? of_node->name : "<unknown>");
-                return NULL;
-        }
-
-        unit_address = (unsigned int *)get_property(of_node, "reg", NULL);
-        if (!unit_address) {
-                printk(KERN_WARNING "%s: node %s missing 'reg'\n", __FUNCTION__,
-                        of_node->name ? of_node->name : "<unknown>");
-                return NULL;
-        }
-
-        /* allocate a vio_dev for this node */
-        viodev = kmalloc(sizeof(struct vio_dev), GFP_KERNEL);
-        if (!viodev) {
-                return NULL;
-        }
-        memset(viodev, 0, sizeof(struct vio_dev));
-
-        viodev->dev.platform_data = of_node_get(of_node);
-
-        viodev->irq = NO_IRQ;
-        irq_p = (unsigned int *)get_property(of_node, "interrupts", NULL);
-        if (irq_p) {
-                int virq = virt_irq_create_mapping(*irq_p);
-                if (virq == NO_IRQ) {
-                        printk(KERN_ERR "Unable to allocate interrupt "
-                               "number for %s\n", of_node->full_name);
-                } else
-                        viodev->irq = irq_offset_up(virq);
-        }
-
-        snprintf(viodev->dev.bus_id, BUS_ID_SIZE, "%x", *unit_address);
-        viodev->name = of_node->name;
-        viodev->type = of_node->type;
-        viodev->unit_address = *unit_address;
-        viodev->iommu_table = vio_build_iommu_table(viodev);
-
-        /* register with generic device framework */
-        if (vio_register_device(viodev) == NULL) {
-                /* XXX free TCE table */
-                kfree(viodev);
-                return NULL;
-        }
-        device_create_file(&viodev->dev, &dev_attr_devspec);
-
-        return viodev;
-}
-EXPORT_SYMBOL(vio_register_device_node);
-
-/**
- * vio_get_attribute: - get attribute for virtual device
- * @vdev:       The vio device to get property.
- * @which:      The property/attribute to be extracted.
- * @length:     Pointer to length of returned data size (unused if NULL).
- *
- * Calls prom.c's get_property() to return the value of the
- * attribute specified by the preprocessor constant @which
-*/
-const void * vio_get_attribute(struct vio_dev *vdev, void* which, int* length)
-{
-        return get_property(vdev->dev.platform_data, (char*)which, length);
-}
-EXPORT_SYMBOL(vio_get_attribute);
-
-/* vio_find_name() - internal because only vio.c knows how we formatted the
- * kobject name
- * XXX once vio_bus_type.devices is actually used as a kset in
- * drivers/base/bus.c, this function should be removed in favor of
- * "device_find(kobj_name, &vio_bus_type)"
- */
-static struct vio_dev *vio_find_name(const char *kobj_name)
-{
-        struct kobject *found;
-
-        found = kset_find_obj(&devices_subsys.kset, kobj_name);
-        if (!found)
-                return NULL;
-
-        return to_vio_dev(container_of(found, struct device, kobj));
-}
-
-/**
- * vio_find_node - find an already-registered vio_dev
- * @vnode: device_node of the virtual device we're looking for
- */
-struct vio_dev *vio_find_node(struct device_node *vnode)
-{
-        uint32_t *unit_address;
-        char kobj_name[BUS_ID_SIZE];
-
-        /* construct the kobject name from the device node */
-        unit_address = (uint32_t *)get_property(vnode, "reg", NULL);
-        if (!unit_address)
-                return NULL;
-        snprintf(kobj_name, BUS_ID_SIZE, "%x", *unit_address);
-
-        return vio_find_name(kobj_name);
-}
-EXPORT_SYMBOL(vio_find_node);
-
-int vio_enable_interrupts(struct vio_dev *dev)
-{
-        int rc = h_vio_signal(dev->unit_address, VIO_IRQ_ENABLE);
-        if (rc != H_SUCCESS)
-                printk(KERN_ERR "vio: Error 0x%x enabling interrupts\n", rc);
-        return rc;
-}
-EXPORT_SYMBOL(vio_enable_interrupts);
-
-int vio_disable_interrupts(struct vio_dev *dev)
-{
-        int rc = h_vio_signal(dev->unit_address, VIO_IRQ_DISABLE);
-        if (rc != H_SUCCESS)
-                printk(KERN_ERR "vio: Error 0x%x disabling interrupts\n", rc);
-        return rc;
-}
-EXPORT_SYMBOL(vio_disable_interrupts);
diff --git a/arch/powerpc/platforms/pseries/xics.c b/arch/powerpc/platforms/pseries/xics.c
index 2d60ea30fed6..b14f9b5c114e 100644
--- a/arch/powerpc/platforms/pseries/xics.c
+++ b/arch/powerpc/platforms/pseries/xics.c
@@ -522,7 +522,7 @@ nextnode:
 
         np = of_find_node_by_type(NULL, "interrupt-controller");
         if (!np) {
-                printk(KERN_WARNING "xics: no ISA interrupt controller\n");
+                printk(KERN_DEBUG "xics: no ISA interrupt controller\n");
                 xics_irq_8259_cascade_real = -1;
                 xics_irq_8259_cascade = -1;
         } else {
@@ -641,23 +641,26 @@ void xics_teardown_cpu(int secondary)
         ops->cppr_info(cpu, 0x00);
         iosync();
 
+        /* Clear IPI */
+        ops->qirr_info(cpu, 0xff);
+
+        /*
+         * we need to EOI the IPI if we got here from kexec down IPI
+         *
+         * probably need to check all the other interrupts too
+         * should we be flagging idle loop instead?
+         * or creating some task to be scheduled?
+         */
+        ops->xirr_info_set(cpu, XICS_IPI);
+
         /*
          * Some machines need to have at least one cpu in the GIQ,
          * so leave the master cpu in the group.
          */
-        if (secondary) {
-                /*
-                 * we need to EOI the IPI if we got here from kexec down IPI
-                 *
-                 * probably need to check all the other interrupts too
-                 * should we be flagging idle loop instead?
-                 * or creating some task to be scheduled?
-                 */
-                ops->xirr_info_set(cpu, XICS_IPI);
+        if (secondary)
                 rtas_set_indicator(GLOBAL_INTERRUPT_QUEUE,
                         (1UL << interrupt_server_size) - 1 -
                         default_distrib_server, 0);
-        }
 }
 
 #ifdef CONFIG_HOTPLUG_CPU
diff --git a/arch/powerpc/sysdev/Makefile b/arch/powerpc/sysdev/Makefile
index 4c2b356774ea..cef95b023730 100644
--- a/arch/powerpc/sysdev/Makefile
+++ b/arch/powerpc/sysdev/Makefile
@@ -1,3 +1,7 @@
+ifeq ($(CONFIG_PPC64),y)
+EXTRA_CFLAGS                    += -mno-minimal-toc
+endif
+
 obj-$(CONFIG_MPIC)              += mpic.o
 obj-$(CONFIG_PPC_INDIRECT_PCI)  += indirect_pci.o
 obj-$(CONFIG_PPC_I8259)         += i8259.o
diff --git a/arch/powerpc/sysdev/dart_iommu.c b/arch/powerpc/sysdev/dart_iommu.c
index 38087bd6e3cf..6232091cc72b 100644
--- a/arch/powerpc/sysdev/dart_iommu.c
+++ b/arch/powerpc/sysdev/dart_iommu.c
@@ -246,7 +246,7 @@ static void iommu_table_dart_setup(void)
         iommu_table_dart.it_base = (unsigned long)dart_vbase;
         iommu_table_dart.it_index = 0;
         iommu_table_dart.it_blocksize = 1;
-        iommu_init_table(&iommu_table_dart);
+        iommu_init_table(&iommu_table_dart, -1);
 
         /* Reserve the last page of the DART to avoid possible prefetch
          * past the DART mapped area
diff --git a/arch/powerpc/sysdev/fsl_soc.c b/arch/powerpc/sysdev/fsl_soc.c
index ceb584682fa3..71a3275935ec 100644
--- a/arch/powerpc/sysdev/fsl_soc.c
+++ b/arch/powerpc/sysdev/fsl_soc.c
@@ -372,7 +372,7 @@ static int __init fsl_usb_of_init(void)
 {
         struct device_node *np;
         unsigned int i;
-        struct platform_device *usb_dev;
+        struct platform_device *usb_dev_mph = NULL, *usb_dev_dr = NULL;
         int ret;
 
         for (np = NULL, i = 0;
@@ -393,15 +393,15 @@ static int __init fsl_usb_of_init(void)
                 r[1].end = np->intrs[0].line;
                 r[1].flags = IORESOURCE_IRQ;
 
-                usb_dev =
-                    platform_device_register_simple("fsl-usb2-mph", i, r, 2);
-                if (IS_ERR(usb_dev)) {
-                        ret = PTR_ERR(usb_dev);
+                usb_dev_mph =
+                    platform_device_register_simple("fsl-ehci", i, r, 2);
+                if (IS_ERR(usb_dev_mph)) {
+                        ret = PTR_ERR(usb_dev_mph);
                         goto err;
                 }
 
-                usb_dev->dev.coherent_dma_mask = 0xffffffffUL;
-                usb_dev->dev.dma_mask = &usb_dev->dev.coherent_dma_mask;
+                usb_dev_mph->dev.coherent_dma_mask = 0xffffffffUL;
+                usb_dev_mph->dev.dma_mask = &usb_dev_mph->dev.coherent_dma_mask;
 
                 usb_data.operating_mode = FSL_USB2_MPH_HOST;
 
@@ -417,31 +417,14 @@ static int __init fsl_usb_of_init(void)
                 usb_data.phy_mode = determine_usb_phy(prop);
 
                 ret =
-                    platform_device_add_data(usb_dev, &usb_data,
+                    platform_device_add_data(usb_dev_mph, &usb_data,
                                              sizeof(struct
                                                     fsl_usb2_platform_data));
                 if (ret)
-                        goto unreg;
+                        goto unreg_mph;
         }
 
-        return 0;
-
-unreg:
-        platform_device_unregister(usb_dev);
-err:
-        return ret;
-}
-
-arch_initcall(fsl_usb_of_init);
-
-static int __init fsl_usb_dr_of_init(void)
-{
-        struct device_node *np;
-        unsigned int i;
-        struct platform_device *usb_dev;
-        int ret;
-
-        for (np = NULL, i = 0;
+        for (np = NULL;
              (np = of_find_compatible_node(np, "usb", "fsl-usb2-dr")) != NULL;
              i++) {
                 struct resource r[2];
@@ -453,21 +436,21 @@ static int __init fsl_usb_dr_of_init(void)
 
                 ret = of_address_to_resource(np, 0, &r[0]);
                 if (ret)
-                        goto err;
+                        goto unreg_mph;
 
                 r[1].start = np->intrs[0].line;
                 r[1].end = np->intrs[0].line;
                 r[1].flags = IORESOURCE_IRQ;
 
-                usb_dev =
-                    platform_device_register_simple("fsl-usb2-dr", i, r, 2);
-                if (IS_ERR(usb_dev)) {
-                        ret = PTR_ERR(usb_dev);
+                usb_dev_dr =
+                    platform_device_register_simple("fsl-ehci", i, r, 2);
+                if (IS_ERR(usb_dev_dr)) {
+                        ret = PTR_ERR(usb_dev_dr);
                         goto err;
                 }
 
-                usb_dev->dev.coherent_dma_mask = 0xffffffffUL;
-                usb_dev->dev.dma_mask = &usb_dev->dev.coherent_dma_mask;
+                usb_dev_dr->dev.coherent_dma_mask = 0xffffffffUL;
+                usb_dev_dr->dev.dma_mask = &usb_dev_dr->dev.coherent_dma_mask;
 
                 usb_data.operating_mode = FSL_USB2_DR_HOST;
 
@@ -475,19 +458,22 @@ static int __init fsl_usb_dr_of_init(void)
                 usb_data.phy_mode = determine_usb_phy(prop);
 
                 ret =
-                    platform_device_add_data(usb_dev, &usb_data,
+                    platform_device_add_data(usb_dev_dr, &usb_data,
                                              sizeof(struct
                                                     fsl_usb2_platform_data));
                 if (ret)
-                        goto unreg;
+                        goto unreg_dr;
         }
-
         return 0;
 
-unreg:
-        platform_device_unregister(usb_dev);
+unreg_dr:
+        if (usb_dev_dr)
+                platform_device_unregister(usb_dev_dr);
+unreg_mph:
+        if (usb_dev_mph)
+                platform_device_unregister(usb_dev_mph);
 err:
         return ret;
 }
 
-arch_initcall(fsl_usb_dr_of_init);
+arch_initcall(fsl_usb_of_init);
diff --git a/arch/powerpc/sysdev/mpic.c b/arch/powerpc/sysdev/mpic.c
index 7dcdfcb3c984..bffe50d02c99 100644
--- a/arch/powerpc/sysdev/mpic.c
+++ b/arch/powerpc/sysdev/mpic.c
@@ -829,7 +829,27 @@ void __init mpic_init(struct mpic *mpic)
         mpic_cpu_write(MPIC_CPU_CURRENT_TASK_PRI, 0);
 }
 
+void __init mpic_set_clk_ratio(struct mpic *mpic, u32 clock_ratio)
+{
+        u32 v;
+
+        v = mpic_read(mpic->gregs, MPIC_GREG_GLOBAL_CONF_1);
+        v &= ~MPIC_GREG_GLOBAL_CONF_1_CLK_RATIO_MASK;
+        v |= MPIC_GREG_GLOBAL_CONF_1_CLK_RATIO(clock_ratio);
+        mpic_write(mpic->gregs, MPIC_GREG_GLOBAL_CONF_1, v);
+}
 
+void __init mpic_set_serial_int(struct mpic *mpic, int enable)
+{
+        u32 v;
+
+        v = mpic_read(mpic->gregs, MPIC_GREG_GLOBAL_CONF_1);
+        if (enable)
+                v |= MPIC_GREG_GLOBAL_CONF_1_SIE;
+        else
+                v &= ~MPIC_GREG_GLOBAL_CONF_1_SIE;
+        mpic_write(mpic->gregs, MPIC_GREG_GLOBAL_CONF_1, v);
+}
 
 void mpic_irq_set_priority(unsigned int irq, unsigned int pri)
 {
diff --git a/arch/ppc/Kconfig b/arch/ppc/Kconfig
index e9a8f5d1dfcd..b55de4f42aec 100644
--- a/arch/ppc/Kconfig
+++ b/arch/ppc/Kconfig
@@ -40,6 +40,10 @@ config GENERIC_NVRAM
         bool
         default y
 
+config GENERIC_FIND_NEXT_BIT
+        bool
+        default y
+
 config SCHED_NO_NO_OMIT_FRAME_POINTER
         bool
         default y
diff --git a/arch/ppc/boot/lib/Makefile b/arch/ppc/boot/lib/Makefile
index 80c84d562fa4..2f995f712ec5 100644
--- a/arch/ppc/boot/lib/Makefile
+++ b/arch/ppc/boot/lib/Makefile
@@ -5,7 +5,7 @@
 CFLAGS_kbd.o    := -Idrivers/char
 CFLAGS_vreset.o := -Iarch/ppc/boot/include
 
-zlib  := infblock.c infcodes.c inffast.c inflate.c inftrees.c infutil.c
+zlib  := inffast.c inflate.c inftrees.c
          
 lib-y += $(zlib:.c=.o) div64.o
 lib-$(CONFIG_VGA_CONSOLE) += vreset.o kbd.o
diff --git a/arch/ppc/mm/init.c b/arch/ppc/mm/init.c
index 386e000bcb73..c9bd184a295a 100644
--- a/arch/ppc/mm/init.c
+++ b/arch/ppc/mm/init.c
@@ -583,7 +583,7 @@ void update_mmu_cache(struct vm_area_struct *vma, unsigned long address,
                 mm = (address < TASK_SIZE)? vma->vm_mm: &init_mm;
                 pmd = pmd_offset(pgd_offset(mm, address), address);
                 if (!pmd_none(*pmd))
-                        add_hash_page(mm->context, address, pmd_val(*pmd));
+                        add_hash_page(mm->context.id, address, pmd_val(*pmd));
         }
 #endif
 }
diff --git a/arch/ppc/mm/mmu_context.c b/arch/ppc/mm/mmu_context.c
index b4a4b3f02a1c..8784f3715032 100644
--- a/arch/ppc/mm/mmu_context.c
+++ b/arch/ppc/mm/mmu_context.c
@@ -30,7 +30,7 @@
 #include <asm/mmu_context.h>
 #include <asm/tlbflush.h>
 
-mm_context_t next_mmu_context;
+unsigned long next_mmu_context;
 unsigned long context_map[LAST_CONTEXT / BITS_PER_LONG + 1];
 #ifdef FEW_CONTEXTS
 atomic_t nr_free_contexts;
diff --git a/arch/ppc/mm/tlb.c b/arch/ppc/mm/tlb.c
index 6c3dc3c44c86..606b023196a2 100644
--- a/arch/ppc/mm/tlb.c
+++ b/arch/ppc/mm/tlb.c
@@ -42,7 +42,7 @@ void flush_hash_entry(struct mm_struct *mm, pte_t *ptep, unsigned long addr)
 
         if (Hash != 0) {
                 ptephys = __pa(ptep) & PAGE_MASK;
-                flush_hash_pages(mm->context, addr, ptephys, 1);
+                flush_hash_pages(mm->context.id, addr, ptephys, 1);
         }
 }
 
@@ -102,7 +102,7 @@ static void flush_range(struct mm_struct *mm, unsigned long start,
         pmd_t *pmd;
         unsigned long pmd_end;
         int count;
-        unsigned int ctx = mm->context;
+        unsigned int ctx = mm->context.id;
 
         if (Hash == 0) {
                 _tlbia();
@@ -166,7 +166,7 @@ void flush_tlb_page(struct vm_area_struct *vma, unsigned long vmaddr)
         mm = (vmaddr < TASK_SIZE)? vma->vm_mm: &init_mm;
         pmd = pmd_offset(pgd_offset(mm, vmaddr), vmaddr);
         if (!pmd_none(*pmd))
-                flush_hash_pages(mm->context, vmaddr, pmd_val(*pmd), 1);
+                flush_hash_pages(mm->context.id, vmaddr, pmd_val(*pmd), 1);
         FINISH_FLUSH;
 }
 
diff --git a/arch/ppc/platforms/4xx/Kconfig b/arch/ppc/platforms/4xx/Kconfig
index 174ddbc9758b..293bd489e7d9 100644
--- a/arch/ppc/platforms/4xx/Kconfig
+++ b/arch/ppc/platforms/4xx/Kconfig
@@ -183,7 +183,7 @@ config IBM_EMAC4
 
 config BIOS_FIXUP
         bool
-        depends on BUBINGA || EP405 || SYCAMORE || WALNUT
+        depends on BUBINGA || EP405 || SYCAMORE || WALNUT || CPCI405
         default y
 
 # OAK doesn't exist but wanted to keep this around for any future 403GCX boards
diff --git a/arch/ppc/platforms/4xx/cpci405.c b/arch/ppc/platforms/4xx/cpci405.c
index 6571e39fbe48..970b69831e6f 100644
--- a/arch/ppc/platforms/4xx/cpci405.c
+++ b/arch/ppc/platforms/4xx/cpci405.c
@@ -1,10 +1,12 @@
 /*
  * Board setup routines for the esd CPCI-405 cPCI Board.
  *
- * Author: Stefan Roese
- *         stefan.roese@esd-electronics.com
+ * Copyright 2001-2006 esd electronic system design - hannover germany
  *
- * Copyright 2001 esd electronic system design - hannover germany
+ * Authors: Matthias Fuchs
+ *          matthias.fuchs@esd-electronics.com
+ *          Stefan Roese
+ *          stefan.roese@esd-electronics.com
  *
  * This program is free software; you can redistribute  it and/or modify it
  * under  the terms of  the GNU General  Public License as published by the
@@ -20,9 +22,17 @@
 #include <asm/pci-bridge.h>
 #include <asm/machdep.h>
 #include <asm/todc.h>
+#include <linux/serial.h>
+#include <linux/serial_core.h>
 #include <asm/ocp.h>
+#include <asm/ibm_ocp_pci.h>
+#include <platforms/4xx/ibm405gp.h>
 
+#ifdef CONFIG_GEN_RTC
 void *cpci405_nvram;
+#endif
+
+extern bd_t __res;
 
 /*
  * Some IRQs unique to CPCI-405.
@@ -36,18 +46,69 @@ ppc405_map_irq(struct pci_dev *dev, unsigned char idsel, unsigned char pin)
          *      A       B       C       D
          */
         {
-                {28,    28,     28,     28},    /* IDSEL 15 - cPCI slot 8 */
-                {29,    29,     29,     29},    /* IDSEL 16 - cPCI slot 7 */
-                {30,    30,     30,     30},    /* IDSEL 17 - cPCI slot 6 */
-                {27,    27,     27,     27},    /* IDSEL 18 - cPCI slot 5 */
-                {28,    28,     28,     28},    /* IDSEL 19 - cPCI slot 4 */
-                {29,    29,     29,     29},    /* IDSEL 20 - cPCI slot 3 */
-                {30,    30,     30,     30},    /* IDSEL 21 - cPCI slot 2 */
+                {28,    29,     30,     27},    /* IDSEL 15 - cPCI slot 8 */
+                {29,    30,     27,     28},    /* IDSEL 16 - cPCI slot 7 */
+                {30,    27,     28,     29},    /* IDSEL 17 - cPCI slot 6 */
+                {27,    28,     29,     30},    /* IDSEL 18 - cPCI slot 5 */
+                {28,    29,     30,     27},    /* IDSEL 19 - cPCI slot 4 */
+                {29,    30,     27,     28},    /* IDSEL 20 - cPCI slot 3 */
+                {30,    27,     28,     29},    /* IDSEL 21 - cPCI slot 2 */
         };
         const long min_idsel = 15, max_idsel = 21, irqs_per_slot = 4;
         return PCI_IRQ_TABLE_LOOKUP;
 };
 
+/* The serial clock for the chip is an internal clock determined by
+ * different clock speeds/dividers.
+ * Calculate the proper input baud rate and setup the serial driver.
+ */
+static void __init
+cpci405_early_serial_map(void)
+{
+        u32 uart_div;
+        int uart_clock;
+        struct uart_port port;
+
+         /* Calculate the serial clock input frequency
+          *
+          * The uart clock is the cpu frequency (provided in the board info
+          * structure) divided by the external UART Divisor.
+          */
+        uart_div = ((mfdcr(DCRN_CHCR_BASE) & CHR0_UDIV) >> 1) + 1;
+        uart_clock = __res.bi_procfreq / uart_div;
+
+        /* Setup serial port access */
+        memset(&port, 0, sizeof(port));
+#if defined(CONFIG_UART0_TTYS0)
+        port.membase = (void*)UART0_IO_BASE;
+        port.irq = UART0_INT;
+#else
+        port.membase = (void*)UART1_IO_BASE;
+        port.irq = UART1_INT;
+#endif
+        port.uartclk = uart_clock;
+        port.regshift = 0;
+        port.iotype = UPIO_MEM;
+        port.flags = UPF_BOOT_AUTOCONF | UPF_SKIP_TEST;
+        port.line = 0;
+
+        if (early_serial_setup(&port) != 0) {
+                printk("Early serial init of port 0 failed\n");
+        }
+#if defined(CONFIG_UART0_TTYS0)
+        port.membase = (void*)UART1_IO_BASE;
+        port.irq = UART1_INT;
+#else
+        port.membase = (void*)UART0_IO_BASE;
+        port.irq = UART0_INT;
+#endif
+        port.line = 1;
+
+        if (early_serial_setup(&port) != 0) {
+                printk("Early serial init of port 1 failed\n");
+        }
+}
+
 void __init
 cpci405_setup_arch(void)
 {
@@ -55,14 +116,68 @@ cpci405_setup_arch(void)
 
         ibm_ocp_set_emac(0, 0);
 
-        TODC_INIT(TODC_TYPE_MK48T35, cpci405_nvram, cpci405_nvram, cpci405_nvram, 8);
+        cpci405_early_serial_map();
+
+#ifdef CONFIG_GEN_RTC
+        TODC_INIT(TODC_TYPE_MK48T35,
+                  cpci405_nvram, cpci405_nvram, cpci405_nvram, 8);
+#endif
+}
+
+void __init
+bios_fixup(struct pci_controller *hose, struct pcil0_regs *pcip)
+{
+        unsigned int bar_response, bar;
+
+        /* Disable region first */
+        out_le32((void *) &(pcip->pmm[0].ma), 0x00000000);
+        /* PLB starting addr, PCI: 0x80000000 */
+        out_le32((void *) &(pcip->pmm[0].la), 0x80000000);
+        /* PCI start addr, 0x80000000 */
+        out_le32((void *) &(pcip->pmm[0].pcila), PPC405_PCI_MEM_BASE);
+        /* 512MB range of PLB to PCI */
+        out_le32((void *) &(pcip->pmm[0].pciha), 0x00000000);
+        /* Enable no pre-fetch, enable region */
+        out_le32((void *) &(pcip->pmm[0].ma), ((0xffffffff -
+                                                (PPC405_PCI_UPPER_MEM -
+                                                 PPC405_PCI_MEM_BASE)) | 0x01));
+
+        /* Disable region one */
+        out_le32((void *) &(pcip->pmm[1].ma), 0x00000000);
+        out_le32((void *) &(pcip->pmm[1].la), 0x00000000);
+        out_le32((void *) &(pcip->pmm[1].pcila), 0x00000000);
+        out_le32((void *) &(pcip->pmm[1].pciha), 0x00000000);
+        out_le32((void *) &(pcip->pmm[1].ma), 0x00000000);
+        out_le32((void *) &(pcip->ptm1ms), 0x00000001);
+
+        /* Disable region two */
+        out_le32((void *) &(pcip->pmm[2].ma), 0x00000000);
+        out_le32((void *) &(pcip->pmm[2].la), 0x00000000);
+        out_le32((void *) &(pcip->pmm[2].pcila), 0x00000000);
+        out_le32((void *) &(pcip->pmm[2].pciha), 0x00000000);
+        out_le32((void *) &(pcip->pmm[2].ma), 0x00000000);
+        out_le32((void *) &(pcip->ptm2ms), 0x00000000);
+        out_le32((void *) &(pcip->ptm2la), 0x00000000);
+
+        /* Zero config bars */
+        for (bar = PCI_BASE_ADDRESS_1; bar <= PCI_BASE_ADDRESS_2; bar += 4) {
+                early_write_config_dword(hose, hose->first_busno,
+                                         PCI_FUNC(hose->first_busno), bar,
+                                         0x00000000);
+                early_read_config_dword(hose, hose->first_busno,
+                                        PCI_FUNC(hose->first_busno), bar,
+                                        &bar_response);
+        }
 }
 
 void __init
 cpci405_map_io(void)
 {
         ppc4xx_map_io();
+
+#ifdef CONFIG_GEN_RTC
         cpci405_nvram = ioremap(CPCI405_NVRAM_PADDR, CPCI405_NVRAM_SIZE);
+#endif
 }
 
 void __init
@@ -74,9 +189,11 @@ platform_init(unsigned long r3, unsigned long r4, unsigned long r5,
         ppc_md.setup_arch = cpci405_setup_arch;
         ppc_md.setup_io_mappings = cpci405_map_io;
 
+#ifdef CONFIG_GEN_RTC
         ppc_md.time_init = todc_time_init;
         ppc_md.set_rtc_time = todc_set_rtc_time;
         ppc_md.get_rtc_time = todc_get_rtc_time;
         ppc_md.nvram_read_val = todc_direct_read_val;
         ppc_md.nvram_write_val = todc_direct_write_val;
+#endif
 }
diff --git a/arch/ppc/platforms/4xx/cpci405.h b/arch/ppc/platforms/4xx/cpci405.h
index e27f7cb650d8..f5a5c0cd062d 100644
--- a/arch/ppc/platforms/4xx/cpci405.h
+++ b/arch/ppc/platforms/4xx/cpci405.h
@@ -1,37 +1,29 @@
 /*
  * CPCI-405 board specific definitions
  *
- * Copyright (c) 2001 Stefan Roese (stefan.roese@esd-electronics.com)
+ * Copyright 2001-2006 esd electronic system design - hannover germany
+ *
+ * Authors: Matthias Fuchs
+ *          matthias.fuchs@esd-electronics.com
+ *          Stefan Roese
+ *          stefan.roese@esd-electronics.com
  */
 
 #ifdef __KERNEL__
-#ifndef __ASM_CPCI405_H__
-#define __ASM_CPCI405_H__
+#ifndef __CPCI405_H__
+#define __CPCI405_H__
 
 #include <linux/config.h>
-
-/* We have a 405GP core */
 #include <platforms/4xx/ibm405gp.h>
-
 #include <asm/ppcboot.h>
 
-#ifndef __ASSEMBLY__
-/* Some 4xx parts use a different timebase frequency from the internal clock.
-*/
-#define bi_tbfreq bi_intfreq
-
 /* Map for the NVRAM space */
 #define CPCI405_NVRAM_PADDR     ((uint)0xf0200000)
 #define CPCI405_NVRAM_SIZE      ((uint)32*1024)
 
-#ifdef CONFIG_PPC405GP_INTERNAL_CLOCK
-#define BASE_BAUD               201600
-#else
-#define BASE_BAUD               691200
-#endif
+#define BASE_BAUD               0
 
-#define PPC4xx_MACHINE_NAME "esd CPCI-405"
+#define PPC4xx_MACHINE_NAME     "esd CPCI-405"
 
-#endif /* !__ASSEMBLY__ */
-#endif  /* __ASM_CPCI405_H__ */
+#endif  /* __CPCI405_H__ */
 #endif /* __KERNEL__ */
diff --git a/arch/ppc/platforms/85xx/mpc85xx_cds_common.c b/arch/ppc/platforms/85xx/mpc85xx_cds_common.c
index c9e0aeeca3d8..4368dc3f3c30 100644
--- a/arch/ppc/platforms/85xx/mpc85xx_cds_common.c
+++ b/arch/ppc/platforms/85xx/mpc85xx_cds_common.c
@@ -379,13 +379,12 @@ mpc85xx_cds_pcibios_fixup(void)
                                         PCI_DEVICE_ID_VIA_82C586_2, NULL))) {
                 dev->irq = 10;
                 pci_write_config_byte(dev, PCI_INTERRUPT_LINE, 10);
-                pci_dev_put(dev);
-        }
 
-        if ((dev = pci_get_device(PCI_VENDOR_ID_VIA,
+                if ((dev = pci_get_device(PCI_VENDOR_ID_VIA,
                                         PCI_DEVICE_ID_VIA_82C586_2, dev))) {
-                dev->irq = 11;
-                pci_write_config_byte(dev, PCI_INTERRUPT_LINE, 11);
+                        dev->irq = 11;
+                        pci_write_config_byte(dev, PCI_INTERRUPT_LINE, 11);
+                }
                 pci_dev_put(dev);
         }
 }
diff --git a/arch/ppc/syslib/mpc83xx_devices.c b/arch/ppc/syslib/mpc83xx_devices.c
index 1af2c000fcfa..5c4932ca8e9b 100644
--- a/arch/ppc/syslib/mpc83xx_devices.c
+++ b/arch/ppc/syslib/mpc83xx_devices.c
@@ -186,7 +186,7 @@ struct platform_device ppc_sys_platform_devices[] = {
                 },
         },
         [MPC83xx_USB2_DR] = {
-                .name = "fsl-usb2-dr",
+                .name = "fsl-ehci",
                 .id     = 1,
                 .num_resources   = 2,
                 .resource = (struct resource[]) {
@@ -203,8 +203,8 @@ struct platform_device ppc_sys_platform_devices[] = {
                 },
         },
         [MPC83xx_USB2_MPH] = {
-                .name = "fsl-usb2-mph",
-                .id     = 1,
+                .name = "fsl-ehci",
+                .id     = 2,
                 .num_resources   = 2,
                 .resource = (struct resource[]) {
                         {
diff --git a/arch/s390/Kconfig b/arch/s390/Kconfig
index 01c5c082f970..821a141889de 100644
--- a/arch/s390/Kconfig
+++ b/arch/s390/Kconfig
@@ -446,6 +446,14 @@ config NO_IDLE_HZ_INIT
           The HZ timer is switched off in idle by default. That means the
           HZ timer is already disabled at boot time.
 
+config S390_HYPFS_FS
+        bool "s390 hypervisor file system support"
+        select SYS_HYPERVISOR
+        default y
+        help
+          This is a virtual file system intended to provide accounting
+          information in an s390 hypervisor environment.
+
 config KEXEC
         bool "kexec system call (EXPERIMENTAL)"
         depends on EXPERIMENTAL
diff --git a/arch/s390/Makefile b/arch/s390/Makefile
index 7bb16fb97d4f..b3791fb094a8 100644
--- a/arch/s390/Makefile
+++ b/arch/s390/Makefile
@@ -76,7 +76,7 @@ LDFLAGS_vmlinux := -e start
 head-y          := arch/$(ARCH)/kernel/head.o arch/$(ARCH)/kernel/init_task.o
 
 core-y          += arch/$(ARCH)/mm/ arch/$(ARCH)/kernel/ arch/$(ARCH)/crypto/ \
-                   arch/$(ARCH)/appldata/
+                   arch/$(ARCH)/appldata/ arch/$(ARCH)/hypfs/
 libs-y          += arch/$(ARCH)/lib/
 drivers-y       += drivers/s390/
 drivers-$(CONFIG_MATHEMU) += arch/$(ARCH)/math-emu/
diff --git a/arch/s390/hypfs/Makefile b/arch/s390/hypfs/Makefile
new file mode 100644
index 000000000000..f4b00cd81f7c
--- /dev/null
+++ b/arch/s390/hypfs/Makefile
@@ -0,0 +1,7 @@
+#
+# Makefile for the linux hypfs filesystem routines.
+#
+
+obj-$(CONFIG_S390_HYPFS_FS) += s390_hypfs.o
+
+s390_hypfs-objs := inode.o hypfs_diag.o
diff --git a/arch/s390/hypfs/hypfs.h b/arch/s390/hypfs/hypfs.h
new file mode 100644
index 000000000000..ea5567be00fc
--- /dev/null
+++ b/arch/s390/hypfs/hypfs.h
@@ -0,0 +1,30 @@
+/*
+ *  fs/hypfs/hypfs.h
+ *    Hypervisor filesystem for Linux on s390.
+ *
+ *    Copyright (C) IBM Corp. 2006
+ *    Author(s): Michael Holzheu <holzheu@de.ibm.com>
+ */
+
+#ifndef _HYPFS_H_
+#define _HYPFS_H_
+
+#include <linux/fs.h>
+#include <linux/types.h>
+
+#define REG_FILE_MODE    0440
+#define UPDATE_FILE_MODE 0220
+#define DIR_MODE         0550
+
+extern struct dentry *hypfs_mkdir(struct super_block *sb, struct dentry *parent,
+                                  const char *name);
+
+extern struct dentry *hypfs_create_u64(struct super_block *sb,
+                                       struct dentry *dir, const char *name,
+                                       __u64 value);
+
+extern struct dentry *hypfs_create_str(struct super_block *sb,
+                                       struct dentry *dir, const char *name,
+                                       char *string);
+
+#endif /* _HYPFS_H_ */
diff --git a/arch/s390/hypfs/hypfs_diag.c b/arch/s390/hypfs/hypfs_diag.c
new file mode 100644
index 000000000000..efa74af7f04a
--- /dev/null
+++ b/arch/s390/hypfs/hypfs_diag.c
@@ -0,0 +1,696 @@
+/*
+ *  fs/hypfs/hypfs_diag.c
+ *    Hypervisor filesystem for Linux on s390. Diag 204 and 224
+ *    implementation.
+ *
+ *    Copyright (C) IBM Corp. 2006
+ *    Author(s): Michael Holzheu <holzheu@de.ibm.com>
+ */
+
+#include <linux/types.h>
+#include <linux/errno.h>
+#include <linux/string.h>
+#include <linux/vmalloc.h>
+#include <asm/ebcdic.h>
+#include "hypfs.h"
+
+#define LPAR_NAME_LEN 8         /* lpar name len in diag 204 data */
+#define CPU_NAME_LEN 16         /* type name len of cpus in diag224 name table */
+#define TMP_SIZE 64             /* size of temporary buffers */
+
+/* diag 204 subcodes */
+enum diag204_sc {
+        SUBC_STIB4 = 4,
+        SUBC_RSI = 5,
+        SUBC_STIB6 = 6,
+        SUBC_STIB7 = 7
+};
+
+/* The two available diag 204 data formats */
+enum diag204_format {
+        INFO_SIMPLE = 0,
+        INFO_EXT = 0x00010000
+};
+
+/* bit is set in flags, when physical cpu info is included in diag 204 data */
+#define LPAR_PHYS_FLG  0x80
+
+static char *diag224_cpu_names;                 /* diag 224 name table */
+static enum diag204_sc diag204_store_sc;        /* used subcode for store */
+static enum diag204_format diag204_info_type;   /* used diag 204 data format */
+
+static void *diag204_buf;               /* 4K aligned buffer for diag204 data */
+static void *diag204_buf_vmalloc;       /* vmalloc pointer for diag204 data */
+static int diag204_buf_pages;           /* number of pages for diag204 data */
+
+/*
+ * DIAG 204 data structures and member access functions.
+ *
+ * Since we have two different diag 204 data formats for old and new s390
+ * machines, we do not access the structs directly, but use getter functions for
+ * each struct member instead. This should make the code more readable.
+ */
+
+/* Time information block */
+
+struct info_blk_hdr {
+        __u8  npar;
+        __u8  flags;
+        __u16 tslice;
+        __u16 phys_cpus;
+        __u16 this_part;
+        __u64 curtod;
+} __attribute__ ((packed));
+
+struct x_info_blk_hdr {
+        __u8  npar;
+        __u8  flags;
+        __u16 tslice;
+        __u16 phys_cpus;
+        __u16 this_part;
+        __u64 curtod1;
+        __u64 curtod2;
+        char reserved[40];
+} __attribute__ ((packed));
+
+static inline int info_blk_hdr__size(enum diag204_format type)
+{
+        if (type == INFO_SIMPLE)
+                return sizeof(struct info_blk_hdr);
+        else /* INFO_EXT */
+                return sizeof(struct x_info_blk_hdr);
+}
+
+static inline __u8 info_blk_hdr__npar(enum diag204_format type, void *hdr)
+{
+        if (type == INFO_SIMPLE)
+                return ((struct info_blk_hdr *)hdr)->npar;
+        else /* INFO_EXT */
+                return ((struct x_info_blk_hdr *)hdr)->npar;
+}
+
+static inline __u8 info_blk_hdr__flags(enum diag204_format type, void *hdr)
+{
+        if (type == INFO_SIMPLE)
+                return ((struct info_blk_hdr *)hdr)->flags;
+        else /* INFO_EXT */
+                return ((struct x_info_blk_hdr *)hdr)->flags;
+}
+
+static inline __u16 info_blk_hdr__pcpus(enum diag204_format type, void *hdr)
+{
+        if (type == INFO_SIMPLE)
+                return ((struct info_blk_hdr *)hdr)->phys_cpus;
+        else /* INFO_EXT */
+                return ((struct x_info_blk_hdr *)hdr)->phys_cpus;
+}
+
+/* Partition header */
+
+struct part_hdr {
+        __u8 pn;
+        __u8 cpus;
+        char reserved[6];
+        char part_name[LPAR_NAME_LEN];
+} __attribute__ ((packed));
+
+struct x_part_hdr {
+        __u8  pn;
+        __u8  cpus;
+        __u8  rcpus;
+        __u8  pflag;
+        __u32 mlu;
+        char  part_name[LPAR_NAME_LEN];
+        char  lpc_name[8];
+        char  os_name[8];
+        __u64 online_cs;
+        __u64 online_es;
+        __u8  upid;
+        char  reserved1[3];
+        __u32 group_mlu;
+        char  group_name[8];
+        char  reserved2[32];
+} __attribute__ ((packed));
+
+static inline int part_hdr__size(enum diag204_format type)
+{
+        if (type == INFO_SIMPLE)
+                return sizeof(struct part_hdr);
+        else /* INFO_EXT */
+                return sizeof(struct x_part_hdr);
+}
+
+static inline __u8 part_hdr__rcpus(enum diag204_format type, void *hdr)
+{
+        if (type == INFO_SIMPLE)
+                return ((struct part_hdr *)hdr)->cpus;
+        else /* INFO_EXT */
+                return ((struct x_part_hdr *)hdr)->rcpus;
+}
+
+static inline void part_hdr__part_name(enum diag204_format type, void *hdr,
+                                       char *name)
+{
+        if (type == INFO_SIMPLE)
+                memcpy(name, ((struct part_hdr *)hdr)->part_name,
+                       LPAR_NAME_LEN);
+        else /* INFO_EXT */
+                memcpy(name, ((struct x_part_hdr *)hdr)->part_name,
+                       LPAR_NAME_LEN);
+        EBCASC(name, LPAR_NAME_LEN);
+        name[LPAR_NAME_LEN] = 0;
+        strstrip(name);
+}
+
+struct cpu_info {
+        __u16 cpu_addr;
+        char  reserved1[2];
+        __u8  ctidx;
+        __u8  cflag;
+        __u16 weight;
+        __u64 acc_time;
+        __u64 lp_time;
+} __attribute__ ((packed));
+
+struct x_cpu_info {
+        __u16 cpu_addr;
+        char  reserved1[2];
+        __u8  ctidx;
+        __u8  cflag;
+        __u16 weight;
+        __u64 acc_time;
+        __u64 lp_time;
+        __u16 min_weight;
+        __u16 cur_weight;
+        __u16 max_weight;
+        char  reseved2[2];
+        __u64 online_time;
+        __u64 wait_time;
+        __u32 pma_weight;
+        __u32 polar_weight;
+        char  reserved3[40];
+} __attribute__ ((packed));
+
+/* CPU info block */
+
+static inline int cpu_info__size(enum diag204_format type)
+{
+        if (type == INFO_SIMPLE)
+                return sizeof(struct cpu_info);
+        else /* INFO_EXT */
+                return sizeof(struct x_cpu_info);
+}
+
+static inline __u8 cpu_info__ctidx(enum diag204_format type, void *hdr)
+{
+        if (type == INFO_SIMPLE)
+                return ((struct cpu_info *)hdr)->ctidx;
+        else /* INFO_EXT */
+                return ((struct x_cpu_info *)hdr)->ctidx;
+}
+
+static inline __u16 cpu_info__cpu_addr(enum diag204_format type, void *hdr)
+{
+        if (type == INFO_SIMPLE)
+                return ((struct cpu_info *)hdr)->cpu_addr;
+        else /* INFO_EXT */
+                return ((struct x_cpu_info *)hdr)->cpu_addr;
+}
+
+static inline __u64 cpu_info__acc_time(enum diag204_format type, void *hdr)
+{
+        if (type == INFO_SIMPLE)
+                return ((struct cpu_info *)hdr)->acc_time;
+        else /* INFO_EXT */
+                return ((struct x_cpu_info *)hdr)->acc_time;
+}
+
+static inline __u64 cpu_info__lp_time(enum diag204_format type, void *hdr)
+{
+        if (type == INFO_SIMPLE)
+                return ((struct cpu_info *)hdr)->lp_time;
+        else /* INFO_EXT */
+                return ((struct x_cpu_info *)hdr)->lp_time;
+}
+
+static inline __u64 cpu_info__online_time(enum diag204_format type, void *hdr)
+{
+        if (type == INFO_SIMPLE)
+                return 0;       /* online_time not available in simple info */
+        else /* INFO_EXT */
+                return ((struct x_cpu_info *)hdr)->online_time;
+}
+
+/* Physical header */
+
+struct phys_hdr {
+        char reserved1[1];
+        __u8 cpus;
+        char reserved2[6];
+        char mgm_name[8];
+} __attribute__ ((packed));
+
+struct x_phys_hdr {
+        char reserved1[1];
+        __u8 cpus;
+        char reserved2[6];
+        char mgm_name[8];
+        char reserved3[80];
+} __attribute__ ((packed));
+
+static inline int phys_hdr__size(enum diag204_format type)
+{
+        if (type == INFO_SIMPLE)
+                return sizeof(struct phys_hdr);
+        else /* INFO_EXT */
+                return sizeof(struct x_phys_hdr);
+}
+
+static inline __u8 phys_hdr__cpus(enum diag204_format type, void *hdr)
+{
+        if (type == INFO_SIMPLE)
+                return ((struct phys_hdr *)hdr)->cpus;
+        else /* INFO_EXT */
+                return ((struct x_phys_hdr *)hdr)->cpus;
+}
+
+/* Physical CPU info block */
+
+struct phys_cpu {
+        __u16 cpu_addr;
+        char  reserved1[2];
+        __u8  ctidx;
+        char  reserved2[3];
+        __u64 mgm_time;
+        char  reserved3[8];
+} __attribute__ ((packed));
+
+struct x_phys_cpu {
+        __u16 cpu_addr;
+        char  reserved1[2];
+        __u8  ctidx;
+        char  reserved2[3];
+        __u64 mgm_time;
+        char  reserved3[80];
+} __attribute__ ((packed));
+
+static inline int phys_cpu__size(enum diag204_format type)
+{
+        if (type == INFO_SIMPLE)
+                return sizeof(struct phys_cpu);
+        else /* INFO_EXT */
+                return sizeof(struct x_phys_cpu);
+}
+
+static inline __u16 phys_cpu__cpu_addr(enum diag204_format type, void *hdr)
+{
+        if (type == INFO_SIMPLE)
+                return ((struct phys_cpu *)hdr)->cpu_addr;
+        else /* INFO_EXT */
+                return ((struct x_phys_cpu *)hdr)->cpu_addr;
+}
+
+static inline __u64 phys_cpu__mgm_time(enum diag204_format type, void *hdr)
+{
+        if (type == INFO_SIMPLE)
+                return ((struct phys_cpu *)hdr)->mgm_time;
+        else /* INFO_EXT */
+                return ((struct x_phys_cpu *)hdr)->mgm_time;
+}
+
+static inline __u64 phys_cpu__ctidx(enum diag204_format type, void *hdr)
+{
+        if (type == INFO_SIMPLE)
+                return ((struct phys_cpu *)hdr)->ctidx;
+        else /* INFO_EXT */
+                return ((struct x_phys_cpu *)hdr)->ctidx;
+}
+
+/* Diagnose 204 functions */
+
+static int diag204(unsigned long subcode, unsigned long size, void *addr)
+{
+        register unsigned long _subcode asm("0") = subcode;
+        register unsigned long _size asm("1") = size;
+
+        asm volatile ("   diag    %2,%0,0x204\n"
+                      "0: \n" ".section __ex_table,\"a\"\n"
+#ifndef __s390x__
+                      "    .align 4\n"
+                      "    .long  0b,0b\n"
+#else
+                      "    .align 8\n"
+                      "    .quad  0b,0b\n"
+#endif
+                      ".previous":"+d" (_subcode), "+d"(_size)
+                      :"d"(addr)
+                      :"memory");
+        if (_subcode)
+                return -1;
+        else
+                return _size;
+}
+
+/*
+ * For the old diag subcode 4 with simple data format we have to use real
+ * memory. If we use subcode 6 or 7 with extended data format, we can (and
+ * should) use vmalloc, since we need a lot of memory in that case. Currently
+ * up to 93 pages!
+ */
+
+static void diag204_free_buffer(void)
+{
+        if (!diag204_buf)
+                return;
+        if (diag204_buf_vmalloc) {
+                vfree(diag204_buf_vmalloc);
+                diag204_buf_vmalloc = NULL;
+        } else {
+                free_pages((unsigned long) diag204_buf, 0);
+        }
+        diag204_buf_pages = 0;
+        diag204_buf = NULL;
+}
+
+static void *diag204_alloc_vbuf(int pages)
+{
+        /* The buffer has to be page aligned! */
+        diag204_buf_vmalloc = vmalloc(PAGE_SIZE * (pages + 1));
+        if (!diag204_buf_vmalloc)
+                return ERR_PTR(-ENOMEM);
+        diag204_buf = (void*)((unsigned long)diag204_buf_vmalloc
+                                & ~0xfffUL) + 0x1000;
+        diag204_buf_pages = pages;
+        return diag204_buf;
+}
+
+static void *diag204_alloc_rbuf(void)
+{
+        diag204_buf = (void*)__get_free_pages(GFP_KERNEL,0);
+        if (diag204_buf)
+                return ERR_PTR(-ENOMEM);
+        diag204_buf_pages = 1;
+        return diag204_buf;
+}
+
+static void *diag204_get_buffer(enum diag204_format fmt, int *pages)
+{
+        if (diag204_buf) {
+                *pages = diag204_buf_pages;
+                return diag204_buf;
+        }
+        if (fmt == INFO_SIMPLE) {
+                *pages = 1;
+                return diag204_alloc_rbuf();
+        } else {/* INFO_EXT */
+                *pages = diag204(SUBC_RSI | INFO_EXT, 0, 0);
+                if (*pages <= 0)
+                        return ERR_PTR(-ENOSYS);
+                else
+                        return diag204_alloc_vbuf(*pages);
+        }
+}
+
+/*
+ * diag204_probe() has to find out, which type of diagnose 204 implementation
+ * we have on our machine. Currently there are three possible scanarios:
+ *   - subcode 4   + simple data format (only one page)
+ *   - subcode 4-6 + extended data format
+ *   - subcode 4-7 + extended data format
+ *
+ * Subcode 5 is used to retrieve the size of the data, provided by subcodes
+ * 6 and 7. Subcode 7 basically has the same function as subcode 6. In addition
+ * to subcode 6 it provides also information about secondary cpus.
+ * In order to get as much information as possible, we first try
+ * subcode 7, then 6 and if both fail, we use subcode 4.
+ */
+
+static int diag204_probe(void)
+{
+        void *buf;
+        int pages, rc;
+
+        buf = diag204_get_buffer(INFO_EXT, &pages);
+        if (!IS_ERR(buf)) {
+                if (diag204(SUBC_STIB7 | INFO_EXT, pages, buf) >= 0) {
+                        diag204_store_sc = SUBC_STIB7;
+                        diag204_info_type = INFO_EXT;
+                        goto out;
+                }
+                if (diag204(SUBC_STIB6 | INFO_EXT, pages, buf) >= 0) {
+                        diag204_store_sc = SUBC_STIB7;
+                        diag204_info_type = INFO_EXT;
+                        goto out;
+                }
+                diag204_free_buffer();
+        }
+
+        /* subcodes 6 and 7 failed, now try subcode 4 */
+
+        buf = diag204_get_buffer(INFO_SIMPLE, &pages);
+        if (IS_ERR(buf)) {
+                rc = PTR_ERR(buf);
+                goto fail_alloc;
+        }
+        if (diag204(SUBC_STIB4 | INFO_SIMPLE, pages, buf) >= 0) {
+                diag204_store_sc = SUBC_STIB4;
+                diag204_info_type = INFO_SIMPLE;
+                goto out;
+        } else {
+                rc = -ENOSYS;
+                goto fail_store;
+        }
+out:
+        rc = 0;
+fail_store:
+        diag204_free_buffer();
+fail_alloc:
+        return rc;
+}
+
+static void *diag204_store(void)
+{
+        void *buf;
+        int pages;
+
+        buf = diag204_get_buffer(diag204_info_type, &pages);
+        if (IS_ERR(buf))
+                goto out;
+        if (diag204(diag204_store_sc | diag204_info_type, pages, buf) < 0)
+                return ERR_PTR(-ENOSYS);
+out:
+        return buf;
+}
+
+/* Diagnose 224 functions */
+
+static void diag224(void *ptr)
+{
+        asm volatile("   diag    %0,%1,0x224\n"
+                     : :"d" (0), "d"(ptr) : "memory");
+}
+
+static int diag224_get_name_table(void)
+{
+        /* memory must be below 2GB */
+        diag224_cpu_names = kmalloc(PAGE_SIZE, GFP_KERNEL | GFP_DMA);
+        if (!diag224_cpu_names)
+                return -ENOMEM;
+        diag224(diag224_cpu_names);
+        EBCASC(diag224_cpu_names + 16, (*diag224_cpu_names + 1) * 16);
+        return 0;
+}
+
+static void diag224_delete_name_table(void)
+{
+        kfree(diag224_cpu_names);
+}
+
+static int diag224_idx2name(int index, char *name)
+{
+        memcpy(name, diag224_cpu_names + ((index + 1) * CPU_NAME_LEN),
+                CPU_NAME_LEN);
+        name[CPU_NAME_LEN] = 0;
+        strstrip(name);
+        return 0;
+}
+
+__init int hypfs_diag_init(void)
+{
+        int rc;
+
+        if (diag204_probe()) {
+                printk(KERN_ERR "hypfs: diag 204 not working.");
+                return -ENODATA;
+        }
+        rc = diag224_get_name_table();
+        if (rc) {
+                diag224_delete_name_table();
+                printk(KERN_ERR "hypfs: could not get name table.\n");
+        }
+        return rc;
+}
+
+__exit void hypfs_diag_exit(void)
+{
+        diag224_delete_name_table();
+        diag204_free_buffer();
+}
+
+/*
+ * Functions to create the directory structure
+ * *******************************************
+ */
+
+static int hypfs_create_cpu_files(struct super_block *sb,
+                                  struct dentry *cpus_dir, void *cpu_info)
+{
+        struct dentry *cpu_dir;
+        char buffer[TMP_SIZE];
+        void *rc;
+
+        snprintf(buffer, TMP_SIZE, "%d", cpu_info__cpu_addr(diag204_info_type,
+                                                            cpu_info));
+        cpu_dir = hypfs_mkdir(sb, cpus_dir, buffer);
+        rc = hypfs_create_u64(sb, cpu_dir, "mgmtime",
+                              cpu_info__acc_time(diag204_info_type, cpu_info) -
+                              cpu_info__lp_time(diag204_info_type, cpu_info));
+        if (IS_ERR(rc))
+                return PTR_ERR(rc);
+        rc = hypfs_create_u64(sb, cpu_dir, "cputime",
+                              cpu_info__lp_time(diag204_info_type, cpu_info));
+        if (IS_ERR(rc))
+                return PTR_ERR(rc);
+        if (diag204_info_type == INFO_EXT) {
+                rc = hypfs_create_u64(sb, cpu_dir, "onlinetime",
+                                      cpu_info__online_time(diag204_info_type,
+                                                            cpu_info));
+                if (IS_ERR(rc))
+                        return PTR_ERR(rc);
+        }
+        diag224_idx2name(cpu_info__ctidx(diag204_info_type, cpu_info), buffer);
+        rc = hypfs_create_str(sb, cpu_dir, "type", buffer);
+        if (IS_ERR(rc))
+                return PTR_ERR(rc);
+        return 0;
+}
+
+static void *hypfs_create_lpar_files(struct super_block *sb,
+                                     struct dentry *systems_dir, void *part_hdr)
+{
+        struct dentry *cpus_dir;
+        struct dentry *lpar_dir;
+        char lpar_name[LPAR_NAME_LEN + 1];
+        void *cpu_info;
+        int i;
+
+        part_hdr__part_name(diag204_info_type, part_hdr, lpar_name);
+        lpar_name[LPAR_NAME_LEN] = 0;
+        lpar_dir = hypfs_mkdir(sb, systems_dir, lpar_name);
+        if (IS_ERR(lpar_dir))
+                return lpar_dir;
+        cpus_dir = hypfs_mkdir(sb, lpar_dir, "cpus");
+        if (IS_ERR(cpus_dir))
+                return cpus_dir;
+        cpu_info = part_hdr + part_hdr__size(diag204_info_type);
+        for (i = 0; i < part_hdr__rcpus(diag204_info_type, part_hdr); i++) {
+                int rc;
+                rc = hypfs_create_cpu_files(sb, cpus_dir, cpu_info);
+                if (rc)
+                        return ERR_PTR(rc);
+                cpu_info += cpu_info__size(diag204_info_type);
+        }
+        return cpu_info;
+}
+
+static int hypfs_create_phys_cpu_files(struct super_block *sb,
+                                       struct dentry *cpus_dir, void *cpu_info)
+{
+        struct dentry *cpu_dir;
+        char buffer[TMP_SIZE];
+        void *rc;
+
+        snprintf(buffer, TMP_SIZE, "%i", phys_cpu__cpu_addr(diag204_info_type,
+                                                            cpu_info));
+        cpu_dir = hypfs_mkdir(sb, cpus_dir, buffer);
+        if (IS_ERR(cpu_dir))
+                return PTR_ERR(cpu_dir);
+        rc = hypfs_create_u64(sb, cpu_dir, "mgmtime",
+                              phys_cpu__mgm_time(diag204_info_type, cpu_info));
+        if (IS_ERR(rc))
+                return PTR_ERR(rc);
+        diag224_idx2name(phys_cpu__ctidx(diag204_info_type, cpu_info), buffer);
+        rc = hypfs_create_str(sb, cpu_dir, "type", buffer);
+        if (IS_ERR(rc))
+                return PTR_ERR(rc);
+        return 0;
+}
+
+static void *hypfs_create_phys_files(struct super_block *sb,
+                                     struct dentry *parent_dir, void *phys_hdr)
+{
+        int i;
+        void *cpu_info;
+        struct dentry *cpus_dir;
+
+        cpus_dir = hypfs_mkdir(sb, parent_dir, "cpus");
+        if (IS_ERR(cpus_dir))
+                return cpus_dir;
+        cpu_info = phys_hdr + phys_hdr__size(diag204_info_type);
+        for (i = 0; i < phys_hdr__cpus(diag204_info_type, phys_hdr); i++) {
+                int rc;
+                rc = hypfs_create_phys_cpu_files(sb, cpus_dir, cpu_info);
+                if (rc)
+                        return ERR_PTR(rc);
+                cpu_info += phys_cpu__size(diag204_info_type);
+        }
+        return cpu_info;
+}
+
+int hypfs_diag_create_files(struct super_block *sb, struct dentry *root)
+{
+        struct dentry *systems_dir, *hyp_dir;
+        void *time_hdr, *part_hdr;
+        int i, rc;
+        void *buffer, *ptr;
+
+        buffer = diag204_store();
+        if (IS_ERR(buffer))
+                return PTR_ERR(buffer);
+
+        systems_dir = hypfs_mkdir(sb, root, "systems");
+        if (IS_ERR(systems_dir)) {
+                rc = PTR_ERR(systems_dir);
+                goto err_out;
+        }
+        time_hdr = (struct x_info_blk_hdr *)buffer;
+        part_hdr = time_hdr + info_blk_hdr__size(diag204_info_type);
+        for (i = 0; i < info_blk_hdr__npar(diag204_info_type, time_hdr); i++) {
+                part_hdr = hypfs_create_lpar_files(sb, systems_dir, part_hdr);
+                if (IS_ERR(part_hdr)) {
+                        rc = PTR_ERR(part_hdr);
+                        goto err_out;
+                }
+        }
+        if (info_blk_hdr__flags(diag204_info_type, time_hdr) & LPAR_PHYS_FLG) {
+                ptr = hypfs_create_phys_files(sb, root, part_hdr);
+                if (IS_ERR(ptr)) {
+                        rc = PTR_ERR(ptr);
+                        goto err_out;
+                }
+        }
+        hyp_dir = hypfs_mkdir(sb, root, "hyp");
+        if (IS_ERR(hyp_dir)) {
+                rc = PTR_ERR(hyp_dir);
+                goto err_out;
+        }
+        ptr = hypfs_create_str(sb, hyp_dir, "type", "LPAR Hypervisor");
+        if (IS_ERR(ptr)) {
+                rc = PTR_ERR(ptr);
+                goto err_out;
+        }
+        rc = 0;
+
+err_out:
+        return rc;
+}
diff --git a/arch/s390/hypfs/hypfs_diag.h b/arch/s390/hypfs/hypfs_diag.h
new file mode 100644
index 000000000000..793dea6b9bb6
--- /dev/null
+++ b/arch/s390/hypfs/hypfs_diag.h
@@ -0,0 +1,16 @@
+/*
+ *  fs/hypfs/hypfs_diag.h
+ *    Hypervisor filesystem for Linux on s390.
+ *
+ *    Copyright (C) IBM Corp. 2006
+ *    Author(s): Michael Holzheu <holzheu@de.ibm.com>
+ */
+
+#ifndef _HYPFS_DIAG_H_
+#define _HYPFS_DIAG_H_
+
+extern int hypfs_diag_init(void);
+extern void hypfs_diag_exit(void);
+extern int hypfs_diag_create_files(struct super_block *sb, struct dentry *root);
+
+#endif /* _HYPFS_DIAG_H_ */
diff --git a/arch/s390/hypfs/inode.c b/arch/s390/hypfs/inode.c
new file mode 100644
index 000000000000..18c091925ea5
--- /dev/null
+++ b/arch/s390/hypfs/inode.c
@@ -0,0 +1,491 @@
+/*
+ *  fs/hypfs/inode.c
+ *    Hypervisor filesystem for Linux on s390.
+ *
+ *    Copyright (C) IBM Corp. 2006
+ *    Author(s): Michael Holzheu <holzheu@de.ibm.com>
+ */
+
+#include <linux/types.h>
+#include <linux/errno.h>
+#include <linux/fs.h>
+#include <linux/namei.h>
+#include <linux/vfs.h>
+#include <linux/pagemap.h>
+#include <linux/gfp.h>
+#include <linux/time.h>
+#include <linux/parser.h>
+#include <linux/sysfs.h>
+#include <linux/module.h>
+#include <asm/ebcdic.h>
+#include "hypfs.h"
+#include "hypfs_diag.h"
+
+#define HYPFS_MAGIC 0x687970    /* ASCII 'hyp' */
+#define TMP_SIZE 64             /* size of temporary buffers */
+
+static struct dentry *hypfs_create_update_file(struct super_block *sb,
+                                               struct dentry *dir);
+
+struct hypfs_sb_info {
+        uid_t uid;                      /* uid used for files and dirs */
+        gid_t gid;                      /* gid used for files and dirs */
+        struct dentry *update_file;     /* file to trigger update */
+        time_t last_update;             /* last update time in secs since 1970 */
+        struct mutex lock;              /* lock to protect update process */
+};
+
+static struct file_operations hypfs_file_ops;
+static struct file_system_type hypfs_type;
+static struct super_operations hypfs_s_ops;
+
+/* start of list of all dentries, which have to be deleted on update */
+static struct dentry *hypfs_last_dentry;
+
+static void hypfs_update_update(struct super_block *sb)
+{
+        struct hypfs_sb_info *sb_info = sb->s_fs_info;
+        struct inode *inode = sb_info->update_file->d_inode;
+
+        sb_info->last_update = get_seconds();
+        inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
+}
+
+/* directory tree removal functions */
+
+static void hypfs_add_dentry(struct dentry *dentry)
+{
+        dentry->d_fsdata = hypfs_last_dentry;
+        hypfs_last_dentry = dentry;
+}
+
+static void hypfs_remove(struct dentry *dentry)
+{
+        struct dentry *parent;
+
+        parent = dentry->d_parent;
+        if (S_ISDIR(dentry->d_inode->i_mode))
+                simple_rmdir(parent->d_inode, dentry);
+        else
+                simple_unlink(parent->d_inode, dentry);
+        d_delete(dentry);
+        dput(dentry);
+}
+
+static void hypfs_delete_tree(struct dentry *root)
+{
+        while (hypfs_last_dentry) {
+                struct dentry *next_dentry;
+                next_dentry = hypfs_last_dentry->d_fsdata;
+                hypfs_remove(hypfs_last_dentry);
+                hypfs_last_dentry = next_dentry;
+        }
+}
+
+static struct inode *hypfs_make_inode(struct super_block *sb, int mode)
+{
+        struct inode *ret = new_inode(sb);
+
+        if (ret) {
+                struct hypfs_sb_info *hypfs_info = sb->s_fs_info;
+                ret->i_mode = mode;
+                ret->i_uid = hypfs_info->uid;
+                ret->i_gid = hypfs_info->gid;
+                ret->i_blksize = PAGE_CACHE_SIZE;
+                ret->i_blocks = 0;
+                ret->i_atime = ret->i_mtime = ret->i_ctime = CURRENT_TIME;
+                if (mode & S_IFDIR)
+                        ret->i_nlink = 2;
+                else
+                        ret->i_nlink = 1;
+        }
+        return ret;
+}
+
+static void hypfs_drop_inode(struct inode *inode)
+{
+        kfree(inode->u.generic_ip);
+        generic_delete_inode(inode);
+}
+
+static int hypfs_open(struct inode *inode, struct file *filp)
+{
+        char *data = filp->f_dentry->d_inode->u.generic_ip;
+        struct hypfs_sb_info *fs_info;
+
+        if (filp->f_mode & FMODE_WRITE) {
+                if (!(inode->i_mode & S_IWUGO))
+                        return -EACCES;
+        }
+        if (filp->f_mode & FMODE_READ) {
+                if (!(inode->i_mode & S_IRUGO))
+                        return -EACCES;
+        }
+
+        fs_info = inode->i_sb->s_fs_info;
+        if(data) {
+                mutex_lock(&fs_info->lock);
+                filp->private_data = kstrdup(data, GFP_KERNEL);
+                if (!filp->private_data) {
+                        mutex_unlock(&fs_info->lock);
+                        return -ENOMEM;
+                }
+                mutex_unlock(&fs_info->lock);
+        }
+        return 0;
+}
+
+static ssize_t hypfs_aio_read(struct kiocb *iocb, __user char *buf,
+                              size_t count, loff_t offset)
+{
+        char *data;
+        size_t len;
+        struct file *filp = iocb->ki_filp;
+
+        data = filp->private_data;
+        len = strlen(data);
+        if (offset > len) {
+                count = 0;
+                goto out;
+        }
+        if (count > len - offset)
+                count = len - offset;
+        if (copy_to_user(buf, data + offset, count)) {
+                count = -EFAULT;
+                goto out;
+        }
+        iocb->ki_pos += count;
+        file_accessed(filp);
+out:
+        return count;
+}
+static ssize_t hypfs_aio_write(struct kiocb *iocb, const char __user *buf,
+                               size_t count, loff_t pos)
+{
+        int rc;
+        struct super_block *sb;
+        struct hypfs_sb_info *fs_info;
+
+        sb = iocb->ki_filp->f_dentry->d_inode->i_sb;
+        fs_info = sb->s_fs_info;
+        /*
+         * Currently we only allow one update per second for two reasons:
+         * 1. diag 204 is VERY expensive
+         * 2. If several processes do updates in parallel and then read the
+         *    hypfs data, the likelihood of collisions is reduced, if we restrict
+         *    the minimum update interval. A collision occurs, if during the
+         *    data gathering of one process another process triggers an update
+         *    If the first process wants to ensure consistent data, it has
+         *    to restart data collection in this case.
+         */
+        mutex_lock(&fs_info->lock);
+        if (fs_info->last_update == get_seconds()) {
+                rc = -EBUSY;
+                goto out;
+        }
+        hypfs_delete_tree(sb->s_root);
+        rc = hypfs_diag_create_files(sb, sb->s_root);
+        if (rc) {
+                printk(KERN_ERR "hypfs: Update failed\n");
+                hypfs_delete_tree(sb->s_root);
+                goto out;
+        }
+        hypfs_update_update(sb);
+        rc = count;
+out:
+        mutex_unlock(&fs_info->lock);
+        return rc;
+}
+
+static int hypfs_release(struct inode *inode, struct file *filp)
+{
+        kfree(filp->private_data);
+        return 0;
+}
+
+enum { opt_uid, opt_gid, opt_err };
+
+static match_table_t hypfs_tokens = {
+        {opt_uid, "uid=%u"},
+        {opt_gid, "gid=%u"},
+        {opt_err, NULL}
+};
+
+static int hypfs_parse_options(char *options, struct super_block *sb)
+{
+        char *str;
+        substring_t args[MAX_OPT_ARGS];
+
+        if (!options)
+                return 0;
+        while ((str = strsep(&options, ",")) != NULL) {
+                int token, option;
+                struct hypfs_sb_info *hypfs_info = sb->s_fs_info;
+
+                if (!*str)
+                        continue;
+                token = match_token(str, hypfs_tokens, args);
+                switch (token) {
+                case opt_uid:
+                        if (match_int(&args[0], &option))
+                                return -EINVAL;
+                        hypfs_info->uid = option;
+                        break;
+                case opt_gid:
+                        if (match_int(&args[0], &option))
+                                return -EINVAL;
+                        hypfs_info->gid = option;
+                        break;
+                case opt_err:
+                default:
+                        printk(KERN_ERR "hypfs: Unrecognized mount option "
+                               "\"%s\" or missing value\n", str);
+                        return -EINVAL;
+                }
+        }
+        return 0;
+}
+
+static int hypfs_fill_super(struct super_block *sb, void *data, int silent)
+{
+        struct inode *root_inode;
+        struct dentry *root_dentry;
+        int rc = 0;
+        struct hypfs_sb_info *sbi;
+
+        sbi = kzalloc(sizeof(struct hypfs_sb_info), GFP_KERNEL);
+        if (!sbi)
+                return -ENOMEM;
+        mutex_init(&sbi->lock);
+        sbi->uid = current->uid;
+        sbi->gid = current->gid;
+        sb->s_fs_info = sbi;
+        sb->s_blocksize = PAGE_CACHE_SIZE;
+        sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
+        sb->s_magic = HYPFS_MAGIC;
+        sb->s_op = &hypfs_s_ops;
+        if (hypfs_parse_options(data, sb)) {
+                rc = -EINVAL;
+                goto err_alloc;
+        }
+        root_inode = hypfs_make_inode(sb, S_IFDIR | 0755);
+        if (!root_inode) {
+                rc = -ENOMEM;
+                goto err_alloc;
+        }
+        root_inode->i_op = &simple_dir_inode_operations;
+        root_inode->i_fop = &simple_dir_operations;
+        root_dentry = d_alloc_root(root_inode);
+        if (!root_dentry) {
+                iput(root_inode);
+                rc = -ENOMEM;
+                goto err_alloc;
+        }
+        rc = hypfs_diag_create_files(sb, root_dentry);
+        if (rc)
+                goto err_tree;
+        sbi->update_file = hypfs_create_update_file(sb, root_dentry);
+        if (IS_ERR(sbi->update_file)) {
+                rc = PTR_ERR(sbi->update_file);
+                goto err_tree;
+        }
+        hypfs_update_update(sb);
+        sb->s_root = root_dentry;
+        return 0;
+
+err_tree:
+        hypfs_delete_tree(root_dentry);
+        d_genocide(root_dentry);
+        dput(root_dentry);
+err_alloc:
+        kfree(sbi);
+        return rc;
+}
+
+static int hypfs_get_super(struct file_system_type *fst, int flags,
+                        const char *devname, void *data, struct vfsmount *mnt)
+{
+        return get_sb_single(fst, flags, data, hypfs_fill_super, mnt);
+}
+
+static void hypfs_kill_super(struct super_block *sb)
+{
+        struct hypfs_sb_info *sb_info = sb->s_fs_info;
+
+        hypfs_delete_tree(sb->s_root);
+        hypfs_remove(sb_info->update_file);
+        kfree(sb->s_fs_info);
+        sb->s_fs_info = NULL;
+        kill_litter_super(sb);
+}
+
+static struct dentry *hypfs_create_file(struct super_block *sb,
+                                        struct dentry *parent, const char *name,
+                                        char *data, mode_t mode)
+{
+        struct dentry *dentry;
+        struct inode *inode;
+        struct qstr qname;
+
+        qname.name = name;
+        qname.len = strlen(name);
+        qname.hash = full_name_hash(name, qname.len);
+        dentry = lookup_one_len(name, parent, strlen(name));
+        if (IS_ERR(dentry))
+                return ERR_PTR(-ENOMEM);
+        inode = hypfs_make_inode(sb, mode);
+        if (!inode) {
+                dput(dentry);
+                return ERR_PTR(-ENOMEM);
+        }
+        if (mode & S_IFREG) {
+                inode->i_fop = &hypfs_file_ops;
+                if (data)
+                        inode->i_size = strlen(data);
+                else
+                        inode->i_size = 0;
+        } else if (mode & S_IFDIR) {
+                inode->i_op = &simple_dir_inode_operations;
+                inode->i_fop = &simple_dir_operations;
+                parent->d_inode->i_nlink++;
+        } else
+                BUG();
+        inode->u.generic_ip = data;
+        d_instantiate(dentry, inode);
+        dget(dentry);
+        return dentry;
+}
+
+struct dentry *hypfs_mkdir(struct super_block *sb, struct dentry *parent,
+                           const char *name)
+{
+        struct dentry *dentry;
+
+        dentry = hypfs_create_file(sb, parent, name, NULL, S_IFDIR | DIR_MODE);
+        if (IS_ERR(dentry))
+                return dentry;
+        hypfs_add_dentry(dentry);
+        parent->d_inode->i_nlink++;
+        return dentry;
+}
+
+static struct dentry *hypfs_create_update_file(struct super_block *sb,
+                                               struct dentry *dir)
+{
+        struct dentry *dentry;
+
+        dentry = hypfs_create_file(sb, dir, "update", NULL,
+                                   S_IFREG | UPDATE_FILE_MODE);
+        /*
+         * We do not put the update file on the 'delete' list with
+         * hypfs_add_dentry(), since it should not be removed when the tree
+         * is updated.
+         */
+        return dentry;
+}
+
+struct dentry *hypfs_create_u64(struct super_block *sb, struct dentry *dir,
+                                const char *name, __u64 value)
+{
+        char *buffer;
+        char tmp[TMP_SIZE];
+        struct dentry *dentry;
+
+        snprintf(tmp, TMP_SIZE, "%lld\n", (unsigned long long int)value);
+        buffer = kstrdup(tmp, GFP_KERNEL);
+        if (!buffer)
+                return ERR_PTR(-ENOMEM);
+        dentry =
+            hypfs_create_file(sb, dir, name, buffer, S_IFREG | REG_FILE_MODE);
+        if (IS_ERR(dentry)) {
+                kfree(buffer);
+                return ERR_PTR(-ENOMEM);
+        }
+        hypfs_add_dentry(dentry);
+        return dentry;
+}
+
+struct dentry *hypfs_create_str(struct super_block *sb, struct dentry *dir,
+                                const char *name, char *string)
+{
+        char *buffer;
+        struct dentry *dentry;
+
+        buffer = kmalloc(strlen(string) + 2, GFP_KERNEL);
+        if (!buffer)
+                return ERR_PTR(-ENOMEM);
+        sprintf(buffer, "%s\n", string);
+        dentry =
+            hypfs_create_file(sb, dir, name, buffer, S_IFREG | REG_FILE_MODE);
+        if (IS_ERR(dentry)) {
+                kfree(buffer);
+                return ERR_PTR(-ENOMEM);
+        }
+        hypfs_add_dentry(dentry);
+        return dentry;
+}
+
+static struct file_operations hypfs_file_ops = {
+        .open           = hypfs_open,
+        .release        = hypfs_release,
+        .read           = do_sync_read,
+        .write          = do_sync_write,
+        .aio_read       = hypfs_aio_read,
+        .aio_write      = hypfs_aio_write,
+};
+
+static struct file_system_type hypfs_type = {
+        .owner          = THIS_MODULE,
+        .name           = "s390_hypfs",
+        .get_sb         = hypfs_get_super,
+        .kill_sb        = hypfs_kill_super
+};
+
+static struct super_operations hypfs_s_ops = {
+        .statfs         = simple_statfs,
+        .drop_inode     = hypfs_drop_inode,
+};
+
+static decl_subsys(s390, NULL, NULL);
+
+static int __init hypfs_init(void)
+{
+        int rc;
+
+        if (MACHINE_IS_VM)
+                return -ENODATA;
+        if (hypfs_diag_init()) {
+                rc = -ENODATA;
+                goto fail_diag;
+        }
+        kset_set_kset_s(&s390_subsys, hypervisor_subsys);
+        rc = subsystem_register(&s390_subsys);
+        if (rc)
+                goto fail_sysfs;
+        rc = register_filesystem(&hypfs_type);
+        if (rc)
+                goto fail_filesystem;
+        return 0;
+
+fail_filesystem:
+        subsystem_unregister(&s390_subsys);
+fail_sysfs:
+        hypfs_diag_exit();
+fail_diag:
+        printk(KERN_ERR "hypfs: Initialization failed with rc = %i.\n", rc);
+        return rc;
+}
+
+static void __exit hypfs_exit(void)
+{
+        hypfs_diag_exit();
+        unregister_filesystem(&hypfs_type);
+        subsystem_unregister(&s390_subsys);
+}
+
+module_init(hypfs_init)
+module_exit(hypfs_exit)
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Michael Holzheu <holzheu@de.ibm.com>");
+MODULE_DESCRIPTION("s390 Hypervisor Filesystem");
diff --git a/arch/sh64/kernel/signal.c b/arch/sh64/kernel/signal.c
index 3ea8929e483b..9e2ffc45c0e0 100644
--- a/arch/sh64/kernel/signal.c
+++ b/arch/sh64/kernel/signal.c
@@ -407,7 +407,7 @@ setup_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs,
 static inline void __user *
 get_sigframe(struct k_sigaction *ka, unsigned long sp, size_t frame_size)
 {
-        if ((ka->sa.sa_flags & SA_ONSTACK) != 0 && ! on_sig_stack(sp))
+        if ((ka->sa.sa_flags & SA_ONSTACK) != 0 && ! sas_ss_flags(sp))
                 sp = current->sas_ss_sp + current->sas_ss_size;
 
         return (void __user *)((sp - frame_size) & -8ul);
diff --git a/arch/sparc/kernel/setup.c b/arch/sparc/kernel/setup.c
index 2cbf282f0d00..a893a9cc9534 100644
--- a/arch/sparc/kernel/setup.c
+++ b/arch/sparc/kernel/setup.c
@@ -332,7 +332,7 @@ void __init setup_arch(char **cmdline_p)
         if (!root_flags)
                 root_mountflags &= ~MS_RDONLY;
         ROOT_DEV = old_decode_dev(root_dev);
-#ifdef CONFIG_BLK_DEV_INITRD
+#ifdef CONFIG_BLK_DEV_RAM
         rd_image_start = ram_flags & RAMDISK_IMAGE_START_MASK;
         rd_prompt = ((ram_flags & RAMDISK_PROMPT_FLAG) != 0);
         rd_doload = ((ram_flags & RAMDISK_LOAD_FLAG) != 0);     
diff --git a/arch/sparc64/solaris/fs.c b/arch/sparc64/solaris/fs.c
index 4885ca6cbc77..0f0eb6aa1c40 100644
--- a/arch/sparc64/solaris/fs.c
+++ b/arch/sparc64/solaris/fs.c
@@ -356,7 +356,7 @@ static int report_statvfs(struct vfsmount *mnt, struct inode *inode, u32 buf)
         int error;
         struct sol_statvfs __user *ss = A(buf);
 
-        error = vfs_statfs(mnt->mnt_sb, &s);
+        error = vfs_statfs(mnt->mnt_root, &s);
         if (!error) {
                 const char *p = mnt->mnt_sb->s_type->name;
                 int i = 0;
@@ -392,7 +392,7 @@ static int report_statvfs64(struct vfsmount *mnt, struct inode *inode, u32 buf)
         int error;
         struct sol_statvfs64 __user *ss = A(buf);
                         
-        error = vfs_statfs(mnt->mnt_sb, &s);
+        error = vfs_statfs(mnt->mnt_root, &s);
         if (!error) {
                 const char *p = mnt->mnt_sb->s_type->name;
                 int i = 0;
diff --git a/arch/um/Kconfig.debug b/arch/um/Kconfig.debug
index 5681a8bd370b..bab51d619173 100644
--- a/arch/um/Kconfig.debug
+++ b/arch/um/Kconfig.debug
@@ -49,7 +49,6 @@ config GCOV
 
 config SYSCALL_DEBUG
         bool "Enable system call debugging"
-        default N
         depends on DEBUG_INFO
         help
         This adds some system debugging to UML, including keeping a ring buffer
diff --git a/arch/um/kernel/time_kern.c b/arch/um/kernel/time_kern.c
index 86f51d04c98d..87cdbc560d36 100644
--- a/arch/um/kernel/time_kern.c
+++ b/arch/um/kernel/time_kern.c
@@ -87,7 +87,7 @@ void timer_irq(union uml_pt_regs *regs)
 
 void time_init_kern(void)
 {
-        unsigned long long nsecs;
+        long long nsecs;
 
         nsecs = os_nsecs();
         set_normalized_timespec(&wall_to_monotonic, -nsecs / BILLION,
diff --git a/arch/um/sys-ppc/misc.S b/arch/um/sys-ppc/misc.S
index 11b7bd768cfd..f0c971db47e4 100644
--- a/arch/um/sys-ppc/misc.S
+++ b/arch/um/sys-ppc/misc.S
@@ -23,14 +23,10 @@
 #define CACHE_LINE_SIZE         16
 #define LG_CACHE_LINE_SIZE      4
 #define MAX_COPY_PREFETCH       1
-#elif !defined(CONFIG_PPC64BRIDGE)
+#else
 #define CACHE_LINE_SIZE         32
 #define LG_CACHE_LINE_SIZE      5
 #define MAX_COPY_PREFETCH       4
-#else
-#define CACHE_LINE_SIZE         128
-#define LG_CACHE_LINE_SIZE      7
-#define MAX_COPY_PREFETCH       1
 #endif /* CONFIG_4xx || CONFIG_8xx */
 
         .text
diff --git a/arch/v850/kernel/signal.c b/arch/v850/kernel/signal.c
index 633e4e1b825f..17c2d4359b04 100644
--- a/arch/v850/kernel/signal.c
+++ b/arch/v850/kernel/signal.c
@@ -274,7 +274,7 @@ get_sigframe(struct k_sigaction *ka, struct pt_regs *regs, size_t frame_size)
         /* Default to using normal stack */
         unsigned long sp = regs->gpr[GPR_SP];
 
-        if ((ka->sa.sa_flags & SA_ONSTACK) != 0 && ! on_sig_stack(sp))
+        if ((ka->sa.sa_flags & SA_ONSTACK) != 0 && ! sas_ss_flags(sp))
                 sp = current->sas_ss_sp + current->sas_ss_size;
 
         return (void *)((sp - frame_size) & -8UL);
diff --git a/arch/x86_64/Kconfig b/arch/x86_64/Kconfig
index 408d44a59756..af44130f0d65 100644
--- a/arch/x86_64/Kconfig
+++ b/arch/x86_64/Kconfig
@@ -299,6 +299,7 @@ config X86_64_ACPI_NUMA
        bool "ACPI NUMA detection"
        depends on NUMA
        select ACPI 
+        select PCI
        select ACPI_NUMA
        default y
        help
@@ -389,6 +390,7 @@ config GART_IOMMU
         bool "K8 GART IOMMU support"
         default y
         select SWIOTLB
+        select AGP
         depends on PCI
         help
           Support for hardware IOMMU in AMD's Opteron/Athlon64 Processors
@@ -401,11 +403,9 @@ config GART_IOMMU
           northbridge and a software emulation used on other systems without
           hardware IOMMU.  If unsure, say Y.
 
-# need this always enabled with GART_IOMMU for the VIA workaround
+# need this always selected by GART_IOMMU for the VIA workaround
 config SWIOTLB
         bool
-        default y
-        depends on GART_IOMMU
 
 config X86_MCE
         bool "Machine check support" if EMBEDDED
diff --git a/arch/x86_64/ia32/ia32entry.S b/arch/x86_64/ia32/ia32entry.S
index 5a92fed2d1d5..4ec594ab1a98 100644
--- a/arch/x86_64/ia32/ia32entry.S
+++ b/arch/x86_64/ia32/ia32entry.S
@@ -696,4 +696,5 @@ ia32_sys_call_table:
         .quad sys_sync_file_range
         .quad sys_tee
         .quad compat_sys_vmsplice
+        .quad compat_sys_move_pages
 ia32_syscall_end:               
diff --git a/arch/x86_64/kernel/acpi/Makefile b/arch/x86_64/kernel/acpi/Makefile
index 4fe97071f297..080b9963f1bc 100644
--- a/arch/x86_64/kernel/acpi/Makefile
+++ b/arch/x86_64/kernel/acpi/Makefile
@@ -4,5 +4,6 @@ obj-$(CONFIG_ACPI_SLEEP)	+= sleep.o wakeup.o
 
 ifneq ($(CONFIG_ACPI_PROCESSOR),)
 obj-y                   += processor.o
+processor-y             := ../../../i386/kernel/acpi/processor.o ../../../i386/kernel/acpi/cstate.o
 endif
 
diff --git a/arch/x86_64/kernel/acpi/processor.c b/arch/x86_64/kernel/acpi/processor.c
deleted file mode 100644
index 3bdc2baa5bb1..000000000000
--- a/arch/x86_64/kernel/acpi/processor.c
+++ /dev/null
@@ -1,72 +0,0 @@
-/*
- * arch/x86_64/kernel/acpi/processor.c
- *
- * Copyright (C) 2005 Intel Corporation
- *      Venkatesh Pallipadi <venkatesh.pallipadi@intel.com>
- *      - Added _PDC for platforms with Intel CPUs
- */
-
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/init.h>
-#include <linux/acpi.h>
-
-#include <acpi/processor.h>
-#include <asm/acpi.h>
-
-static void init_intel_pdc(struct acpi_processor *pr, struct cpuinfo_x86 *c)
-{
-        struct acpi_object_list *obj_list;
-        union acpi_object *obj;
-        u32 *buf;
-
-        /* allocate and initialize pdc. It will be used later. */
-        obj_list = kmalloc(sizeof(struct acpi_object_list), GFP_KERNEL);
-        if (!obj_list) {
-                printk(KERN_ERR "Memory allocation error\n");
-                return;
-        }
-
-        obj = kmalloc(sizeof(union acpi_object), GFP_KERNEL);
-        if (!obj) {
-                printk(KERN_ERR "Memory allocation error\n");
-                kfree(obj_list);
-                return;
-        }
-
-        buf = kmalloc(12, GFP_KERNEL);
-        if (!buf) {
-                printk(KERN_ERR "Memory allocation error\n");
-                kfree(obj);
-                kfree(obj_list);
-                return;
-        }
-
-        buf[0] = ACPI_PDC_REVISION_ID;
-        buf[1] = 1;
-        buf[2] = ACPI_PDC_EST_CAPABILITY_SMP;
-
-        obj->type = ACPI_TYPE_BUFFER;
-        obj->buffer.length = 12;
-        obj->buffer.pointer = (u8 *) buf;
-        obj_list->count = 1;
-        obj_list->pointer = obj;
-        pr->pdc = obj_list;
-
-        return;
-}
-
-/* Initialize _PDC data based on the CPU vendor */
-void arch_acpi_processor_init_pdc(struct acpi_processor *pr)
-{
-        unsigned int cpu = pr->id;
-        struct cpuinfo_x86 *c = cpu_data + cpu;
-
-        pr->pdc = NULL;
-        if (c->x86_vendor == X86_VENDOR_INTEL && cpu_has(c, X86_FEATURE_EST))
-                init_intel_pdc(pr, c);
-
-        return;
-}
-
-EXPORT_SYMBOL(arch_acpi_processor_init_pdc);
diff --git a/arch/x86_64/kernel/acpi/sleep.c b/arch/x86_64/kernel/acpi/sleep.c
index 867a0ebee177..091bc79c888f 100644
--- a/arch/x86_64/kernel/acpi/sleep.c
+++ b/arch/x86_64/kernel/acpi/sleep.c
@@ -35,6 +35,8 @@
 #include <linux/pci.h>
 #include <linux/bootmem.h>
 #include <linux/acpi.h>
+#include <linux/cpumask.h>
+
 #include <asm/mpspec.h>
 #include <asm/io.h>
 #include <asm/apic.h>
@@ -66,7 +68,8 @@ static void init_low_mapping(void)
         pgd_t *slot0 = pgd_offset(current->mm, 0UL);
         low_ptr = *slot0;
         set_pgd(slot0, *pgd_offset(current->mm, PAGE_OFFSET));
-        flush_tlb_all();
+        WARN_ON(num_online_cpus() != 1);
+        local_flush_tlb();
 }
 
 /**
@@ -92,7 +95,7 @@ int acpi_save_state_mem(void)
 void acpi_restore_state_mem(void)
 {
         set_pgd(pgd_offset(current->mm, 0UL), low_ptr);
-        flush_tlb_all();
+        local_flush_tlb();
 }
 
 /**
diff --git a/arch/x86_64/kernel/apic.c b/arch/x86_64/kernel/apic.c
index 100a30c40044..29ef99001e05 100644
--- a/arch/x86_64/kernel/apic.c
+++ b/arch/x86_64/kernel/apic.c
@@ -51,7 +51,7 @@ int disable_apic_timer __initdata;
 static cpumask_t timer_interrupt_broadcast_ipi_mask;
 
 /* Using APIC to generate smp_local_timer_interrupt? */
-int using_apic_timer = 0;
+int using_apic_timer __read_mostly = 0;
 
 static void apic_pm_activate(void);
 
diff --git a/arch/x86_64/kernel/i387.c b/arch/x86_64/kernel/i387.c
index a5d7e16b928e..44ddb1ec808d 100644
--- a/arch/x86_64/kernel/i387.c
+++ b/arch/x86_64/kernel/i387.c
@@ -24,7 +24,7 @@
 #include <asm/ptrace.h>
 #include <asm/uaccess.h>
 
-unsigned int mxcsr_feature_mask = 0xffffffff;
+unsigned int mxcsr_feature_mask __read_mostly = 0xffffffff;
 
 void mxcsr_feature_mask_init(void)
 {
diff --git a/arch/x86_64/kernel/setup.c b/arch/x86_64/kernel/setup.c
index 655b9192eeb3..b8d5116d7371 100644
--- a/arch/x86_64/kernel/setup.c
+++ b/arch/x86_64/kernel/setup.c
@@ -47,6 +47,7 @@
 #include <linux/dmi.h>
 #include <linux/dma-mapping.h>
 #include <linux/ctype.h>
+#include <linux/suspend.h>
 
 #include <asm/mtrr.h>
 #include <asm/uaccess.h>
@@ -595,6 +596,100 @@ static void discover_ebda(void)
                 ebda_size = 64*1024;
 }
 
+#ifdef CONFIG_SOFTWARE_SUSPEND
+static void __init mark_nosave_page_range(unsigned long start, unsigned long end)
+{
+        struct page *page;
+        while (start <= end) {
+                page = pfn_to_page(start);
+                SetPageNosave(page);
+                start++;
+        }
+}
+
+static void __init e820_nosave_reserved_pages(void)
+{
+        int i;
+        unsigned long r_start = 0, r_end = 0;
+
+        /* Assume e820 map is sorted */
+        for (i = 0; i < e820.nr_map; i++) {
+                struct e820entry *ei = &e820.map[i];
+                unsigned long start, end;
+
+                start = round_down(ei->addr, PAGE_SIZE);
+                end = round_up(ei->addr + ei->size, PAGE_SIZE);
+                if (start >= end)
+                        continue;
+                if (ei->type == E820_RESERVED)
+                        continue;
+                r_end = start>>PAGE_SHIFT;
+                /* swsusp ignores invalid pfn, ignore these pages here */
+                if (r_end > end_pfn)
+                        r_end = end_pfn;
+                if (r_end > r_start)
+                        mark_nosave_page_range(r_start, r_end-1);
+                if (r_end >= end_pfn)
+                        break;
+                r_start = end>>PAGE_SHIFT;
+        }
+}
+
+static void __init e820_save_acpi_pages(void)
+{
+        int i;
+
+        /* Assume e820 map is sorted */
+        for (i = 0; i < e820.nr_map; i++) {
+                struct e820entry *ei = &e820.map[i];
+                unsigned long start, end;
+
+                start = ei->addr, PAGE_SIZE;
+                end = ei->addr + ei->size;
+                if (start >= end)
+                        continue;
+                if (ei->type != E820_ACPI && ei->type != E820_NVS)
+                        continue;
+                /*
+                 * If the region is below end_pfn, it will be
+                 * saved/restored by swsusp follow 'RAM' type.
+                 */
+                if (start < (end_pfn << PAGE_SHIFT))
+                        start = end_pfn << PAGE_SHIFT;
+                if (end > start)
+                        swsusp_add_arch_pages(start, end);
+        }
+}
+
+extern char __start_rodata, __end_rodata;
+/*
+ * BIOS reserved region/hole - no save/restore
+ * ACPI NVS - save/restore
+ * ACPI Data - this is a little tricky, the mem could be used by OS after OS
+ * reads tables from the region, but anyway save/restore the memory hasn't any
+ * side effect and Linux runtime module load/unload might use it.
+ * kernel rodata - no save/restore (kernel rodata isn't changed)
+ */
+static int __init mark_nosave_pages(void)
+{
+        unsigned long pfn_start, pfn_end;
+
+        /* BIOS reserved regions & holes */
+        e820_nosave_reserved_pages();
+
+        /* kernel rodata */
+        pfn_start = round_up(__pa_symbol(&__start_rodata), PAGE_SIZE) >> PAGE_SHIFT;
+        pfn_end = round_down(__pa_symbol(&__end_rodata), PAGE_SIZE) >> PAGE_SHIFT;
+        mark_nosave_page_range(pfn_start, pfn_end-1);
+
+        /* record ACPI Data/NVS as saveable */
+        e820_save_acpi_pages();
+
+        return 0;
+}
+core_initcall(mark_nosave_pages);
+#endif
+
 void __init setup_arch(char **cmdline_p)
 {
         unsigned long kernel_end;
diff --git a/arch/x86_64/mm/srat.c b/arch/x86_64/mm/srat.c
index 474df22c6ed2..502fce65e96a 100644
--- a/arch/x86_64/mm/srat.c
+++ b/arch/x86_64/mm/srat.c
@@ -30,7 +30,6 @@
 static struct acpi_table_slit *acpi_slit;
 
 static nodemask_t nodes_parsed __initdata;
-static nodemask_t nodes_found __initdata;
 static struct bootnode nodes[MAX_NUMNODES] __initdata;
 static struct bootnode nodes_add[MAX_NUMNODES] __initdata;
 static int found_add_area __initdata;
@@ -38,33 +37,14 @@ int hotadd_percent __initdata = 0;
 #ifndef RESERVE_HOTADD
 #define hotadd_percent 0        /* Ignore all settings */
 #endif
-static u8 pxm2node[256] = { [0 ... 255] = 0xff };
 
 /* Too small nodes confuse the VM badly. Usually they result
    from BIOS bugs. */
 #define NODE_MIN_SIZE (4*1024*1024)
 
-static int node_to_pxm(int n);
-
-int pxm_to_node(int pxm)
-{
-        if ((unsigned)pxm >= 256)
-                return -1;
-        /* Extend 0xff to (int)-1 */
-        return (signed char)pxm2node[pxm];
-}
-
 static __init int setup_node(int pxm)
 {
-        unsigned node = pxm2node[pxm];
-        if (node == 0xff) {
-                if (nodes_weight(nodes_found) >= MAX_NUMNODES)
-                        return -1;
-                node = first_unset_node(nodes_found); 
-                node_set(node, nodes_found);
-                pxm2node[pxm] = node;
-        }
-        return pxm2node[pxm];
+        return acpi_map_pxm_to_node(pxm);
 }
 
 static __init int conflicting_nodes(unsigned long start, unsigned long end)
@@ -440,17 +420,6 @@ int __init acpi_scan_nodes(unsigned long start, unsigned long end)
         return 0;
 }
 
-static int node_to_pxm(int n)
-{
-       int i;
-       if (pxm2node[n] == n)
-               return n;
-       for (i = 0; i < 256; i++)
-               if (pxm2node[i] == n)
-                       return i;
-       return 0;
-}
-
 void __init srat_reserve_add_area(int nodeid)
 {
         if (found_add_area && nodes_add[nodeid].end) {
diff --git a/arch/x86_64/pci/mmconfig.c b/arch/x86_64/pci/mmconfig.c
index a2060e4d5de6..3c55c76c6fd5 100644
--- a/arch/x86_64/pci/mmconfig.c
+++ b/arch/x86_64/pci/mmconfig.c
@@ -13,7 +13,10 @@
 
 #include "pci.h"
 
-#define MMCONFIG_APER_SIZE (256*1024*1024)
+/* aperture is up to 256MB but BIOS may reserve less */
+#define MMCONFIG_APER_MIN       (2 * 1024*1024)
+#define MMCONFIG_APER_MAX       (256 * 1024*1024)
+
 /* Verify the first 16 busses. We assume that systems with more busses
    get MCFG right. */
 #define MAX_CHECK_BUS 16
@@ -175,9 +178,10 @@ void __init pci_mmcfg_init(void)
                 return;
 
         if (!e820_all_mapped(pci_mmcfg_config[0].base_address,
-                        pci_mmcfg_config[0].base_address + MMCONFIG_APER_SIZE,
+                        pci_mmcfg_config[0].base_address + MMCONFIG_APER_MIN,
                         E820_RESERVED)) {
-                printk(KERN_ERR "PCI: BIOS Bug: MCFG area is not E820-reserved\n");
+                printk(KERN_ERR "PCI: BIOS Bug: MCFG area at %x is not E820-reserved\n",
+                                pci_mmcfg_config[0].base_address);
                 printk(KERN_ERR "PCI: Not using MMCONFIG.\n");
                 return;
         }
@@ -190,7 +194,8 @@ void __init pci_mmcfg_init(void)
         }
         for (i = 0; i < pci_mmcfg_config_num; ++i) {
                 pci_mmcfg_virt[i].cfg = &pci_mmcfg_config[i];
-                pci_mmcfg_virt[i].virt = ioremap_nocache(pci_mmcfg_config[i].base_address, MMCONFIG_APER_SIZE);
+                pci_mmcfg_virt[i].virt = ioremap_nocache(pci_mmcfg_config[i].base_address,
+                                                         MMCONFIG_APER_MAX);
                 if (!pci_mmcfg_virt[i].virt) {
                         printk("PCI: Cannot map mmconfig aperture for segment %d\n",
                                pci_mmcfg_config[i].pci_segment_group_number);
diff --git a/arch/xtensa/Kconfig b/arch/xtensa/Kconfig
index dbeb3504c3c8..848f173db257 100644
--- a/arch/xtensa/Kconfig
+++ b/arch/xtensa/Kconfig
@@ -34,10 +34,6 @@ config GENERIC_HARDIRQS
         bool
         default y
 
-config RWSEM_GENERIC_SPINLOCK
-       bool
-       default y
-
 source "init/Kconfig"
 
 menu "Processor type and features"
diff --git a/arch/xtensa/boot/lib/Makefile b/arch/xtensa/boot/lib/Makefile
index 9e73bb8aeb7a..d3d2aa2d883a 100644
--- a/arch/xtensa/boot/lib/Makefile
+++ b/arch/xtensa/boot/lib/Makefile
@@ -2,7 +2,7 @@
 # Makefile for some libs needed by zImage.
 #
 
-zlib    := infblock.c infcodes.c inffast.c inflate.c inftrees.c infutil.c
+zlib    := inffast.c inflate.c inftrees.c
 
 lib-y   += $(zlib:.c=.o) zmem.o
 
diff --git a/arch/xtensa/kernel/entry.S b/arch/xtensa/kernel/entry.S
index 5c018c503dfa..89e409e9e0de 100644
--- a/arch/xtensa/kernel/entry.S
+++ b/arch/xtensa/kernel/entry.S
@@ -1102,7 +1102,7 @@ ENTRY(fast_syscall_sysxtensa)
         s32i    a7, a2, PT_AREG7
 
         movi    a7, 4                   # sizeof(unsigned int)
-        verify_area a3, a7, a0, a2, .Leac
+        access_ok a0, a3, a7, a2, .Leac
 
         _beqi   a6, SYSXTENSA_ATOMIC_SET, .Lset
         _beqi   a6, SYSXTENSA_ATOMIC_EXG_ADD, .Lexg
diff --git a/arch/xtensa/kernel/signal.c b/arch/xtensa/kernel/signal.c
index e252b61e45a5..c494f0826fc5 100644
--- a/arch/xtensa/kernel/signal.c
+++ b/arch/xtensa/kernel/signal.c
@@ -104,7 +104,7 @@ sys_sigaction(int sig, const struct old_sigaction *act,
 
         if (act) {
                 old_sigset_t mask;
-                if (verify_area(VERIFY_READ, act, sizeof(*act)) ||
+                if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
                     __get_user(new_ka.sa.sa_handler, &act->sa_handler) ||
                     __get_user(new_ka.sa.sa_restorer, &act->sa_restorer))
                         return -EFAULT;
@@ -116,7 +116,7 @@ sys_sigaction(int sig, const struct old_sigaction *act,
         ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
 
         if (!ret && oact) {
-                if (verify_area(VERIFY_WRITE, oact, sizeof(*oact)) ||
+                if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
                     __put_user(old_ka.sa.sa_handler, &oact->sa_handler) ||
                     __put_user(old_ka.sa.sa_restorer, &oact->sa_restorer))
                         return -EFAULT;
@@ -236,7 +236,7 @@ restore_sigcontext(struct pt_regs *regs, struct sigcontext *sc)
         err |= __copy_from_user (regs->areg, sc->sc_areg, XCHAL_NUM_AREGS*4);
         err |= __get_user(buf, &sc->sc_cpstate);
         if (buf) {
-                if (verify_area(VERIFY_READ, buf, sizeof(*buf)))
+                if (!access_ok(VERIFY_READ, buf, sizeof(*buf)))
                         goto badframe;
                 err |= restore_cpextra(buf);
         }
@@ -357,7 +357,7 @@ asmlinkage int sys_sigreturn(struct pt_regs *regs)
         if (regs->depc > 64)
                 panic ("Double exception sys_sigreturn\n");
 
-        if (verify_area(VERIFY_READ, frame, sizeof(*frame)))
+        if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
                 goto badframe;
 
         if (__get_user(set.sig[0], &frame->sc.oldmask)
@@ -394,7 +394,7 @@ asmlinkage int sys_rt_sigreturn(struct pt_regs *regs)
                 return 0;
         }
 
-        if (verify_area(VERIFY_READ, frame, sizeof(*frame)))
+        if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
                 goto badframe;
 
         if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
@@ -433,7 +433,7 @@ badframe:
 static inline void *
 get_sigframe(struct k_sigaction *ka, unsigned long sp, size_t frame_size)
 {
-        if ((ka->sa.sa_flags & SA_ONSTACK) != 0 && ! on_sig_stack(sp))
+        if ((ka->sa.sa_flags & SA_ONSTACK) != 0 && ! sas_ss_flags(sp))
                 sp = current->sas_ss_sp + current->sas_ss_size;
 
         return (void *)((sp - frame_size) & -16ul);