112 files changed, 10926 insertions, 1991 deletions

diff --git a/arch/powerpc/platforms/4xx/Kconfig b/arch/powerpc/platforms/4xx/Kconfig
index ed39d6a3d22a..2f2a13ed7667 100644
--- a/arch/powerpc/platforms/4xx/Kconfig
+++ b/arch/powerpc/platforms/4xx/Kconfig
@@ -179,7 +179,7 @@ config BIOS_FIXUP
 # OAK doesn't exist but wanted to keep this around for any future 403GCX boards
 config 403GCX
         bool
-        depends OAK
+        depends on OAK
         default y
 
 config 405EP
diff --git a/arch/powerpc/platforms/52xx/Makefile b/arch/powerpc/platforms/52xx/Makefile
new file mode 100644
index 000000000000..a46184a0c750
--- /dev/null
+++ b/arch/powerpc/platforms/52xx/Makefile
@@ -0,0 +1,9 @@
+#
+# Makefile for 52xx based boards
+#
+ifeq ($(CONFIG_PPC_MERGE),y)
+obj-y                           += mpc52xx_pic.o mpc52xx_common.o
+endif
+
+obj-$(CONFIG_PPC_EFIKA)         += efika-setup.o efika-pci.o
+obj-$(CONFIG_PPC_LITE5200)      += lite5200.o
diff --git a/arch/powerpc/platforms/52xx/efika-pci.c b/arch/powerpc/platforms/52xx/efika-pci.c
new file mode 100644
index 000000000000..62e05b2a9227
--- /dev/null
+++ b/arch/powerpc/platforms/52xx/efika-pci.c
@@ -0,0 +1,119 @@
+
+#include <linux/kernel.h>
+#include <linux/pci.h>
+#include <linux/string.h>
+#include <linux/init.h>
+
+#include <asm/io.h>
+#include <asm/irq.h>
+#include <asm/prom.h>
+#include <asm/machdep.h>
+#include <asm/sections.h>
+#include <asm/pci-bridge.h>
+#include <asm/rtas.h>
+
+#include "efika.h"
+
+#ifdef CONFIG_PCI
+/*
+ * Access functions for PCI config space using RTAS calls.
+ */
+static int rtas_read_config(struct pci_bus *bus, unsigned int devfn, int offset,
+                            int len, u32 * val)
+{
+        struct pci_controller *hose = bus->sysdata;
+        unsigned long addr = (offset & 0xff) | ((devfn & 0xff) << 8)
+            | (((bus->number - hose->first_busno) & 0xff) << 16)
+            | (hose->index << 24);
+        int ret = -1;
+        int rval;
+
+        rval = rtas_call(rtas_token("read-pci-config"), 2, 2, &ret, addr, len);
+        *val = ret;
+        return rval ? PCIBIOS_DEVICE_NOT_FOUND : PCIBIOS_SUCCESSFUL;
+}
+
+static int rtas_write_config(struct pci_bus *bus, unsigned int devfn,
+                             int offset, int len, u32 val)
+{
+        struct pci_controller *hose = bus->sysdata;
+        unsigned long addr = (offset & 0xff) | ((devfn & 0xff) << 8)
+            | (((bus->number - hose->first_busno) & 0xff) << 16)
+            | (hose->index << 24);
+        int rval;
+
+        rval = rtas_call(rtas_token("write-pci-config"), 3, 1, NULL,
+                         addr, len, val);
+        return rval ? PCIBIOS_DEVICE_NOT_FOUND : PCIBIOS_SUCCESSFUL;
+}
+
+static struct pci_ops rtas_pci_ops = {
+        rtas_read_config,
+        rtas_write_config
+};
+
+void __init efika_pcisetup(void)
+{
+        const int *bus_range;
+        int len;
+        struct pci_controller *hose;
+        struct device_node *root;
+        struct device_node *pcictrl;
+
+        root = of_find_node_by_path("/");
+        if (root == NULL) {
+                printk(KERN_WARNING EFIKA_PLATFORM_NAME
+                       ": Unable to find the root node\n");
+                return;
+        }
+
+        for (pcictrl = NULL;;) {
+                pcictrl = of_get_next_child(root, pcictrl);
+                if ((pcictrl == NULL) || (strcmp(pcictrl->name, "pci") == 0))
+                        break;
+        }
+
+        of_node_put(root);
+
+        if (pcictrl == NULL) {
+                printk(KERN_WARNING EFIKA_PLATFORM_NAME
+                       ": Unable to find the PCI bridge node\n");
+                return;
+        }
+
+        bus_range = get_property(pcictrl, "bus-range", &len);
+        if (bus_range == NULL || len < 2 * sizeof(int)) {
+                printk(KERN_WARNING EFIKA_PLATFORM_NAME
+                       ": Can't get bus-range for %s\n", pcictrl->full_name);
+                return;
+        }
+
+        if (bus_range[1] == bus_range[0])
+                printk(KERN_INFO EFIKA_PLATFORM_NAME ": PCI bus %d",
+                       bus_range[0]);
+        else
+                printk(KERN_INFO EFIKA_PLATFORM_NAME ": PCI buses %d..%d",
+                       bus_range[0], bus_range[1]);
+        printk(" controlled by %s\n", pcictrl->full_name);
+        printk("\n");
+
+        hose = pcibios_alloc_controller();
+        if (!hose) {
+                printk(KERN_WARNING EFIKA_PLATFORM_NAME
+                       ": Can't allocate PCI controller structure for %s\n",
+                       pcictrl->full_name);
+                return;
+        }
+
+        hose->arch_data = of_node_get(pcictrl);
+        hose->first_busno = bus_range[0];
+        hose->last_busno = bus_range[1];
+        hose->ops = &rtas_pci_ops;
+
+        pci_process_bridge_OF_ranges(hose, pcictrl, 0);
+}
+
+#else
+void __init efika_pcisetup(void)
+{}
+#endif
diff --git a/arch/powerpc/platforms/52xx/efika-setup.c b/arch/powerpc/platforms/52xx/efika-setup.c
new file mode 100644
index 000000000000..110c980ed1e0
--- /dev/null
+++ b/arch/powerpc/platforms/52xx/efika-setup.c
@@ -0,0 +1,150 @@
+/*
+ *
+ * Efika 5K2 platform setup
+ * Some code really inspired from the lite5200b platform.
+ * 
+ * Copyright (C) 2006 bplan GmbH
+ *
+ * This file is licensed under the terms of the GNU General Public License
+ * version 2. This program is licensed "as is" without any warranty of any
+ * kind, whether express or implied.
+ *
+ */
+
+#include <linux/errno.h>
+#include <linux/kernel.h>
+#include <linux/slab.h>
+#include <linux/reboot.h>
+#include <linux/init.h>
+#include <linux/utsrelease.h>
+#include <linux/seq_file.h>
+#include <linux/root_dev.h>
+#include <linux/initrd.h>
+#include <linux/timer.h>
+#include <linux/pci.h>
+
+#include <asm/pgtable.h>
+#include <asm/prom.h>
+#include <asm/time.h>
+#include <asm/machdep.h>
+#include <asm/rtas.h>
+#include <asm/of_device.h>
+#include <asm/of_platform.h>
+#include <asm/mpc52xx.h>
+
+#include "efika.h"
+
+static void efika_show_cpuinfo(struct seq_file *m)
+{
+        struct device_node *root;
+        const char *revision = NULL;
+        const char *codegendescription = NULL;
+        const char *codegenvendor = NULL;
+
+        root = of_find_node_by_path("/");
+        if (root) {
+                revision = get_property(root, "revision", NULL);
+                codegendescription =
+                    get_property(root, "CODEGEN,description", NULL);
+                codegenvendor = get_property(root, "CODEGEN,vendor", NULL);
+
+                of_node_put(root);
+        }
+
+        if (codegendescription)
+                seq_printf(m, "machine\t\t: %s\n", codegendescription);
+        else
+                seq_printf(m, "machine\t\t: Efika\n");
+
+        if (revision)
+                seq_printf(m, "revision\t: %s\n", revision);
+
+        if (codegenvendor)
+                seq_printf(m, "vendor\t\t: %s\n", codegenvendor);
+
+        of_node_put(root);
+}
+
+static void __init efika_setup_arch(void)
+{
+        rtas_initialize();
+
+#ifdef CONFIG_BLK_DEV_INITRD
+        initrd_below_start_ok = 1;
+
+        if (initrd_start)
+                ROOT_DEV = Root_RAM0;
+        else
+#endif
+                ROOT_DEV = Root_SDA2;   /* sda2 (sda1 is for the kernel) */
+
+        efika_pcisetup();
+
+        if (ppc_md.progress)
+                ppc_md.progress("Linux/PPC " UTS_RELEASE " runnung on Efika ;-)\n", 0x0);
+}
+
+static void __init efika_init(void)
+{
+        struct device_node *np;
+        struct device_node *cnp = NULL;
+        const u32 *base;
+
+        /* Find every child of the SOC node and add it to of_platform */
+        np = of_find_node_by_name(NULL, "builtin");
+        if (np) {
+                char name[BUS_ID_SIZE];
+                while ((cnp = of_get_next_child(np, cnp))) {
+                        strcpy(name, cnp->name);
+
+                        base = get_property(cnp, "reg", NULL);
+                        if (base == NULL)
+                                continue;
+
+                        snprintf(name+strlen(name), BUS_ID_SIZE, "@%x", *base);
+                        of_platform_device_create(cnp, name, NULL);
+
+                        printk(KERN_INFO EFIKA_PLATFORM_NAME" : Added %s (type '%s' at '%s') to the known devices\n", name, cnp->type, cnp->full_name);
+                }
+        }
+
+        if (ppc_md.progress)
+                ppc_md.progress("  Have fun with your Efika!    ", 0x7777);
+}
+
+static int __init efika_probe(void)
+{
+        char *model = of_get_flat_dt_prop(of_get_flat_dt_root(),
+                                          "model", NULL);
+
+        if (model == NULL)
+                return 0;
+        if (strcmp(model, "EFIKA5K2"))
+                return 0;
+
+        ISA_DMA_THRESHOLD = ~0L;
+        DMA_MODE_READ = 0x44;
+        DMA_MODE_WRITE = 0x48;
+
+        return 1;
+}
+
+define_machine(efika)
+{
+        .name = EFIKA_PLATFORM_NAME,
+        .probe = efika_probe,
+        .setup_arch = efika_setup_arch,
+        .init = efika_init,
+        .show_cpuinfo = efika_show_cpuinfo,
+        .init_IRQ = mpc52xx_init_irq,
+        .get_irq = mpc52xx_get_irq,
+        .restart = rtas_restart,
+        .power_off = rtas_power_off,
+        .halt = rtas_halt,
+        .set_rtc_time = rtas_set_rtc_time,
+        .get_rtc_time = rtas_get_rtc_time,
+        .progress = rtas_progress,
+        .get_boot_time = rtas_get_boot_time,
+        .calibrate_decr = generic_calibrate_decr,
+        .phys_mem_access_prot = pci_phys_mem_access_prot,
+};
diff --git a/arch/powerpc/platforms/52xx/efika.h b/arch/powerpc/platforms/52xx/efika.h
new file mode 100644
index 000000000000..2f060fd097d7
--- /dev/null
+++ b/arch/powerpc/platforms/52xx/efika.h
@@ -0,0 +1,19 @@
+/*
+ * Efika 5K2 platform setup - Header file
+ *
+ * Copyright (C) 2006 bplan GmbH
+ *
+ * This file is licensed under the terms of the GNU General Public License
+ * version 2. This program is licensed "as is" without any warranty of any
+ * kind, whether express or implied.
+ *
+ */
+
+#ifndef __ARCH_POWERPC_EFIKA__
+#define __ARCH_POWERPC_EFIKA__
+
+#define EFIKA_PLATFORM_NAME "Efika"
+
+extern void __init efika_pcisetup(void);
+
+#endif
diff --git a/arch/powerpc/platforms/52xx/lite5200.c b/arch/powerpc/platforms/52xx/lite5200.c
new file mode 100644
index 000000000000..0f21bab33f6c
--- /dev/null
+++ b/arch/powerpc/platforms/52xx/lite5200.c
@@ -0,0 +1,161 @@
+/*
+ * Freescale Lite5200 board support
+ *
+ * Written by: Grant Likely <grant.likely@secretlab.ca>
+ *
+ * Copyright (C) Secret Lab Technologies Ltd. 2006. All rights reserved.
+ * Copyright (C) Freescale Semicondutor, Inc. 2006. All rights reserved.
+ *
+ * Description:
+ * 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/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 <asm/system.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/irq.h>
+#include <asm/prom.h>
+#include <asm/udbg.h>
+#include <sysdev/fsl_soc.h>
+#include <asm/of_platform.h>
+
+#include <asm/mpc52xx.h>
+
+/* ************************************************************************
+ *
+ * Setup the architecture
+ *
+ */
+
+static void __init
+lite52xx_setup_cpu(void)
+{
+        struct mpc52xx_gpio __iomem *gpio;
+        u32 port_config;
+
+        /* Map zones */
+        gpio = mpc52xx_find_and_map("mpc52xx-gpio");
+        if (!gpio) {
+                printk(KERN_ERR __FILE__ ": "
+                        "Error while mapping GPIO register for port config. "
+                        "Expect some abnormal behavior\n");
+                goto error;
+        }
+
+        /* Set port config */
+        port_config = in_be32(&gpio->port_config);
+
+        port_config &= ~0x00800000;     /* 48Mhz internal, pin is GPIO  */
+
+        port_config &= ~0x00007000;     /* USB port : Differential mode */
+        port_config |=  0x00001000;     /*            USB 1 only        */
+
+        port_config &= ~0x03000000;     /* ATA CS is on csb_4/5         */
+        port_config |=  0x01000000;
+
+        pr_debug("port_config: old:%x new:%x\n",
+                 in_be32(&gpio->port_config), port_config);
+        out_be32(&gpio->port_config, port_config);
+
+        /* Unmap zone */
+error:
+        iounmap(gpio);
+}
+
+static void __init lite52xx_setup_arch(void)
+{
+        struct device_node *np;
+
+        if (ppc_md.progress)
+                ppc_md.progress("lite52xx_setup_arch()", 0);
+
+        np = of_find_node_by_type(NULL, "cpu");
+        if (np) {
+                unsigned int *fp =
+                    (int *)get_property(np, "clock-frequency", NULL);
+                if (fp != 0)
+                        loops_per_jiffy = *fp / HZ;
+                else
+                        loops_per_jiffy = 50000000 / HZ;
+                of_node_put(np);
+        }
+
+        /* CPU & Port mux setup */
+        mpc52xx_setup_cpu();    /* Generic */
+        lite52xx_setup_cpu();   /* Platorm specific */
+
+#ifdef CONFIG_BLK_DEV_INITRD
+        if (initrd_start)
+                ROOT_DEV = Root_RAM0;
+        else
+#endif
+#ifdef  CONFIG_ROOT_NFS
+                ROOT_DEV = Root_NFS;
+#else
+                ROOT_DEV = Root_HDA1;
+#endif
+
+}
+
+void lite52xx_show_cpuinfo(struct seq_file *m)
+{
+        struct device_node* np = of_find_all_nodes(NULL);
+        const char *model = NULL;
+
+        if (np)
+                model = get_property(np, "model", NULL);
+
+        seq_printf(m, "vendor\t\t:      Freescale Semiconductor\n");
+        seq_printf(m, "machine\t\t:     %s\n", model ? model : "unknown");
+
+        of_node_put(np);
+}
+
+/*
+ * Called very early, MMU is off, device-tree isn't unflattened
+ */
+static int __init lite52xx_probe(void)
+{
+        unsigned long node = of_get_flat_dt_root();
+        const char *model = of_get_flat_dt_prop(node, "model", NULL);
+
+        if (!of_flat_dt_is_compatible(node, "lite52xx"))
+                return 0;
+        pr_debug("%s board w/ mpc52xx found\n", model ? model : "unknown");
+
+        return 1;
+}
+
+define_machine(lite52xx) {
+        .name           = "lite52xx",
+        .probe          = lite52xx_probe,
+        .setup_arch     = lite52xx_setup_arch,
+        .init           = mpc52xx_declare_of_platform_devices,
+        .init_IRQ       = mpc52xx_init_irq,
+        .get_irq        = mpc52xx_get_irq,
+        .show_cpuinfo   = lite52xx_show_cpuinfo,
+        .calibrate_decr = generic_calibrate_decr,
+};
diff --git a/arch/powerpc/platforms/52xx/mpc52xx_common.c b/arch/powerpc/platforms/52xx/mpc52xx_common.c
new file mode 100644
index 000000000000..cc40889074bd
--- /dev/null
+++ b/arch/powerpc/platforms/52xx/mpc52xx_common.c
@@ -0,0 +1,127 @@
+/*
+ *
+ * Utility functions for the Freescale MPC52xx.
+ *
+ * Copyright (C) 2006 Sylvain Munaut <tnt@246tNt.com>
+ *
+ * This file is licensed under the terms of the GNU General Public License
+ * version 2. This program is licensed "as is" without any warranty of any
+ * kind, whether express or implied.
+ *
+ */
+
+#undef DEBUG
+
+#include <linux/kernel.h>
+
+#include <asm/io.h>
+#include <asm/prom.h>
+#include <asm/of_platform.h>
+#include <asm/mpc52xx.h>
+
+
+void __iomem *
+mpc52xx_find_and_map(const char *compatible)
+{
+        struct device_node *ofn;
+        const u32 *regaddr_p;
+        u64 regaddr64, size64;
+
+        ofn = of_find_compatible_node(NULL, NULL, compatible);
+        if (!ofn)
+                return NULL;
+
+        regaddr_p = of_get_address(ofn, 0, &size64, NULL);
+        if (!regaddr_p) {
+                of_node_put(ofn);
+                return NULL;
+        }
+
+        regaddr64 = of_translate_address(ofn, regaddr_p);
+
+        of_node_put(ofn);
+
+        return ioremap((u32)regaddr64, (u32)size64);
+}
+EXPORT_SYMBOL(mpc52xx_find_and_map);
+
+
+/**
+ *      mpc52xx_find_ipb_freq - Find the IPB bus frequency for a device
+ *      @node:  device node
+ *
+ *      Returns IPB bus frequency, or 0 if the bus frequency cannot be found.
+ */
+unsigned int
+mpc52xx_find_ipb_freq(struct device_node *node)
+{
+        struct device_node *np;
+        const unsigned int *p_ipb_freq = NULL;
+
+        of_node_get(node);
+        while (node) {
+                p_ipb_freq = get_property(node, "bus-frequency", NULL);
+                if (p_ipb_freq)
+                        break;
+
+                np = of_get_parent(node);
+                of_node_put(node);
+                node = np;
+        }
+        if (node)
+                of_node_put(node);
+
+        return p_ipb_freq ? *p_ipb_freq : 0;
+}
+EXPORT_SYMBOL(mpc52xx_find_ipb_freq);
+
+
+void __init
+mpc52xx_setup_cpu(void)
+{
+        struct mpc52xx_cdm  __iomem *cdm;
+        struct mpc52xx_xlb  __iomem *xlb;
+
+        /* Map zones */
+        cdm = mpc52xx_find_and_map("mpc52xx-cdm");
+        xlb = mpc52xx_find_and_map("mpc52xx-xlb");
+
+        if (!cdm || !xlb) {
+                printk(KERN_ERR __FILE__ ": "
+                        "Error while mapping CDM/XLB during mpc52xx_setup_cpu. "
+                        "Expect some abnormal behavior\n");
+                goto unmap_regs;
+        }
+
+        /* Use internal 48 Mhz */
+        out_8(&cdm->ext_48mhz_en, 0x00);
+        out_8(&cdm->fd_enable, 0x01);
+        if (in_be32(&cdm->rstcfg) & 0x40)       /* Assumes 33Mhz clock */
+                out_be16(&cdm->fd_counters, 0x0001);
+        else
+                out_be16(&cdm->fd_counters, 0x5555);
+
+        /* Configure the XLB Arbiter priorities */
+        out_be32(&xlb->master_pri_enable, 0xff);
+        out_be32(&xlb->master_priority, 0x11111111);
+
+        /* Disable XLB pipelining */
+        /* (cfr errate 292. We could do this only just before ATA PIO
+            transaction and re-enable it afterwards ...) */
+        out_be32(&xlb->config, in_be32(&xlb->config) | MPC52xx_XLB_CFG_PLDIS);
+
+        /* Unmap zones */
+unmap_regs:
+        if (cdm) iounmap(cdm);
+        if (xlb) iounmap(xlb);
+}
+
+void __init
+mpc52xx_declare_of_platform_devices(void)
+{
+        /* Find every child of the SOC node and add it to of_platform */
+        if (of_platform_bus_probe(NULL, NULL, NULL))
+                printk(KERN_ERR __FILE__ ": "
+                        "Error while probing of_platform bus\n");
+}
+
diff --git a/arch/powerpc/platforms/52xx/mpc52xx_pic.c b/arch/powerpc/platforms/52xx/mpc52xx_pic.c
new file mode 100644
index 000000000000..cd91a6c3aafa
--- /dev/null
+++ b/arch/powerpc/platforms/52xx/mpc52xx_pic.c
@@ -0,0 +1,473 @@
+/*
+ *
+ * Programmable Interrupt Controller functions for the Freescale MPC52xx.
+ *
+ * Copyright (C) 2006 bplan GmbH
+ *
+ * Based on the code from the 2.4 kernel by
+ * Dale Farnsworth <dfarnsworth@mvista.com> and Kent Borg.
+ *
+ * Copyright (C) 2004 Sylvain Munaut <tnt@246tNt.com>
+ * Copyright (C) 2003 Montavista Software, Inc
+ *
+ * This file is licensed under the terms of the GNU General Public License
+ * version 2. This program is licensed "as is" without any warranty of any
+ * kind, whether express or implied.
+ *
+ */
+
+#undef DEBUG
+
+#include <linux/stddef.h>
+#include <linux/init.h>
+#include <linux/sched.h>
+#include <linux/signal.h>
+#include <linux/stddef.h>
+#include <linux/delay.h>
+#include <linux/irq.h>
+#include <linux/hardirq.h>
+
+#include <asm/io.h>
+#include <asm/processor.h>
+#include <asm/system.h>
+#include <asm/irq.h>
+#include <asm/prom.h>
+#include <asm/mpc52xx.h>
+#include "mpc52xx_pic.h"
+
+/*
+ *
+*/
+
+static struct mpc52xx_intr __iomem *intr;
+static struct mpc52xx_sdma __iomem *sdma;
+static struct irq_host *mpc52xx_irqhost = NULL;
+
+static unsigned char mpc52xx_map_senses[4] = {
+        IRQ_TYPE_LEVEL_HIGH,
+        IRQ_TYPE_EDGE_RISING,
+        IRQ_TYPE_EDGE_FALLING,
+        IRQ_TYPE_LEVEL_LOW,
+};
+
+/*
+ *
+*/
+
+static inline void io_be_setbit(u32 __iomem *addr, int bitno)
+{
+        out_be32(addr, in_be32(addr) | (1 << bitno));
+}
+
+static inline void io_be_clrbit(u32 __iomem *addr, int bitno)
+{
+        out_be32(addr, in_be32(addr) & ~(1 << bitno));
+}
+
+/*
+ * IRQ[0-3] interrupt irq_chip
+*/
+
+static void mpc52xx_extirq_mask(unsigned int virq)
+{
+        int irq;
+        int l2irq;
+
+        irq = irq_map[virq].hwirq;
+        l2irq = (irq & MPC52xx_IRQ_L2_MASK) >> MPC52xx_IRQ_L2_OFFSET;
+
+        pr_debug("%s: irq=%x. l2=%d\n", __func__, irq, l2irq);
+
+        io_be_clrbit(&intr->ctrl, 11 - l2irq);
+}
+
+static void mpc52xx_extirq_unmask(unsigned int virq)
+{
+        int irq;
+        int l2irq;
+
+        irq = irq_map[virq].hwirq;
+        l2irq = (irq & MPC52xx_IRQ_L2_MASK) >> MPC52xx_IRQ_L2_OFFSET;
+
+        pr_debug("%s: irq=%x. l2=%d\n", __func__, irq, l2irq);
+
+        io_be_setbit(&intr->ctrl, 11 - l2irq);
+}
+
+static void mpc52xx_extirq_ack(unsigned int virq)
+{
+        int irq;
+        int l2irq;
+
+        irq = irq_map[virq].hwirq;
+        l2irq = (irq & MPC52xx_IRQ_L2_MASK) >> MPC52xx_IRQ_L2_OFFSET;
+
+        pr_debug("%s: irq=%x. l2=%d\n", __func__, irq, l2irq);
+
+        io_be_setbit(&intr->ctrl, 27-l2irq);
+}
+
+static struct irq_chip mpc52xx_extirq_irqchip = {
+        .typename = " MPC52xx IRQ[0-3] ",
+        .mask = mpc52xx_extirq_mask,
+        .unmask = mpc52xx_extirq_unmask,
+        .ack = mpc52xx_extirq_ack,
+};
+
+/*
+ * Main interrupt irq_chip
+*/
+
+static void mpc52xx_main_mask(unsigned int virq)
+{
+        int irq;
+        int l2irq;
+
+        irq = irq_map[virq].hwirq;
+        l2irq = (irq & MPC52xx_IRQ_L2_MASK) >> MPC52xx_IRQ_L2_OFFSET;
+
+        pr_debug("%s: irq=%x. l2=%d\n", __func__, irq, l2irq);
+
+        io_be_setbit(&intr->main_mask, 15 - l2irq);
+}
+
+static void mpc52xx_main_unmask(unsigned int virq)
+{
+        int irq;
+        int l2irq;
+
+        irq = irq_map[virq].hwirq;
+        l2irq = (irq & MPC52xx_IRQ_L2_MASK) >> MPC52xx_IRQ_L2_OFFSET;
+
+        pr_debug("%s: irq=%x. l2=%d\n", __func__, irq, l2irq);
+
+        io_be_clrbit(&intr->main_mask, 15 - l2irq);
+}
+
+static struct irq_chip mpc52xx_main_irqchip = {
+        .typename = "MPC52xx Main",
+        .mask = mpc52xx_main_mask,
+        .mask_ack = mpc52xx_main_mask,
+        .unmask = mpc52xx_main_unmask,
+};
+
+/*
+ * Peripherals interrupt irq_chip
+*/
+
+static void mpc52xx_periph_mask(unsigned int virq)
+{
+        int irq;
+        int l2irq;
+
+        irq = irq_map[virq].hwirq;
+        l2irq = (irq & MPC52xx_IRQ_L2_MASK) >> MPC52xx_IRQ_L2_OFFSET;
+
+        pr_debug("%s: irq=%x. l2=%d\n", __func__, irq, l2irq);
+
+        io_be_setbit(&intr->per_mask, 31 - l2irq);
+}
+
+static void mpc52xx_periph_unmask(unsigned int virq)
+{
+        int irq;
+        int l2irq;
+
+        irq = irq_map[virq].hwirq;
+        l2irq = (irq & MPC52xx_IRQ_L2_MASK) >> MPC52xx_IRQ_L2_OFFSET;
+
+        pr_debug("%s: irq=%x. l2=%d\n", __func__, irq, l2irq);
+
+        io_be_clrbit(&intr->per_mask, 31 - l2irq);
+}
+
+static struct irq_chip mpc52xx_periph_irqchip = {
+        .typename = "MPC52xx Peripherals",
+        .mask = mpc52xx_periph_mask,
+        .mask_ack = mpc52xx_periph_mask,
+        .unmask = mpc52xx_periph_unmask,
+};
+
+/*
+ * SDMA interrupt irq_chip
+*/
+
+static void mpc52xx_sdma_mask(unsigned int virq)
+{
+        int irq;
+        int l2irq;
+
+        irq = irq_map[virq].hwirq;
+        l2irq = (irq & MPC52xx_IRQ_L2_MASK) >> MPC52xx_IRQ_L2_OFFSET;
+
+        pr_debug("%s: irq=%x. l2=%d\n", __func__, irq, l2irq);
+
+        io_be_setbit(&sdma->IntMask, l2irq);
+}
+
+static void mpc52xx_sdma_unmask(unsigned int virq)
+{
+        int irq;
+        int l2irq;
+
+        irq = irq_map[virq].hwirq;
+        l2irq = (irq & MPC52xx_IRQ_L2_MASK) >> MPC52xx_IRQ_L2_OFFSET;
+
+        pr_debug("%s: irq=%x. l2=%d\n", __func__, irq, l2irq);
+
+        io_be_clrbit(&sdma->IntMask, l2irq);
+}
+
+static void mpc52xx_sdma_ack(unsigned int virq)
+{
+        int irq;
+        int l2irq;
+
+        irq = irq_map[virq].hwirq;
+        l2irq = (irq & MPC52xx_IRQ_L2_MASK) >> MPC52xx_IRQ_L2_OFFSET;
+
+        pr_debug("%s: irq=%x. l2=%d\n", __func__, irq, l2irq);
+
+        out_be32(&sdma->IntPend, 1 << l2irq);
+}
+
+static struct irq_chip mpc52xx_sdma_irqchip = {
+        .typename = "MPC52xx SDMA",
+        .mask = mpc52xx_sdma_mask,
+        .unmask = mpc52xx_sdma_unmask,
+        .ack = mpc52xx_sdma_ack,
+};
+
+/*
+ * irq_host
+*/
+
+static int mpc52xx_irqhost_match(struct irq_host *h, struct device_node *node)
+{
+        pr_debug("%s: node=%p\n", __func__, node);
+        return mpc52xx_irqhost->host_data == node;
+}
+
+static int mpc52xx_irqhost_xlate(struct irq_host *h, struct device_node *ct,
+                                 u32 * intspec, unsigned int intsize,
+                                 irq_hw_number_t * out_hwirq,
+                                 unsigned int *out_flags)
+{
+        int intrvect_l1;
+        int intrvect_l2;
+        int intrvect_type;
+        int intrvect_linux;
+
+        if (intsize != 3)
+                return -1;
+
+        intrvect_l1 = (int)intspec[0];
+        intrvect_l2 = (int)intspec[1];
+        intrvect_type = (int)intspec[2];
+
+        intrvect_linux =
+            (intrvect_l1 << MPC52xx_IRQ_L1_OFFSET) & MPC52xx_IRQ_L1_MASK;
+        intrvect_linux |=
+            (intrvect_l2 << MPC52xx_IRQ_L2_OFFSET) & MPC52xx_IRQ_L2_MASK;
+
+        pr_debug("return %x, l1=%d, l2=%d\n", intrvect_linux, intrvect_l1,
+                 intrvect_l2);
+
+        *out_hwirq = intrvect_linux;
+        *out_flags = mpc52xx_map_senses[intrvect_type];
+
+        return 0;
+}
+
+/*
+ * this function retrieves the correct IRQ type out
+ * of the MPC regs
+ * Only externals IRQs needs this
+*/
+static int mpc52xx_irqx_gettype(int irq)
+{
+        int type;
+        u32 ctrl_reg;
+
+        ctrl_reg = in_be32(&intr->ctrl);
+        type = (ctrl_reg >> (22 - irq * 2)) & 0x3;
+
+        return mpc52xx_map_senses[type];
+}
+
+static int mpc52xx_irqhost_map(struct irq_host *h, unsigned int virq,
+                               irq_hw_number_t irq)
+{
+        int l1irq;
+        int l2irq;
+        struct irq_chip *good_irqchip;
+        void *good_handle;
+        int type;
+
+        l1irq = (irq & MPC52xx_IRQ_L1_MASK) >> MPC52xx_IRQ_L1_OFFSET;
+        l2irq = (irq & MPC52xx_IRQ_L2_MASK) >> MPC52xx_IRQ_L2_OFFSET;
+
+        /*
+         * Most of ours IRQs will be level low
+         * Only external IRQs on some platform may be others
+         */
+        type = IRQ_TYPE_LEVEL_LOW;
+
+        switch (l1irq) {
+        case MPC52xx_IRQ_L1_CRIT:
+                pr_debug("%s: Critical. l2=%x\n", __func__, l2irq);
+
+                BUG_ON(l2irq != 0);
+
+                type = mpc52xx_irqx_gettype(l2irq);
+                good_irqchip = &mpc52xx_extirq_irqchip;
+                break;
+
+        case MPC52xx_IRQ_L1_MAIN:
+                pr_debug("%s: Main IRQ[1-3] l2=%x\n", __func__, l2irq);
+
+                if ((l2irq >= 1) && (l2irq <= 3)) {
+                        type = mpc52xx_irqx_gettype(l2irq);
+                        good_irqchip = &mpc52xx_extirq_irqchip;
+                } else {
+                        good_irqchip = &mpc52xx_main_irqchip;
+                }
+                break;
+
+        case MPC52xx_IRQ_L1_PERP:
+                pr_debug("%s: Peripherals. l2=%x\n", __func__, l2irq);
+                good_irqchip = &mpc52xx_periph_irqchip;
+                break;
+
+        case MPC52xx_IRQ_L1_SDMA:
+                pr_debug("%s: SDMA. l2=%x\n", __func__, l2irq);
+                good_irqchip = &mpc52xx_sdma_irqchip;
+                break;
+
+        default:
+                pr_debug("%s: Error, unknown L1 IRQ (0x%x)\n", __func__, l1irq);
+                printk(KERN_ERR "Unknow IRQ!\n");
+                return -EINVAL;
+        }
+
+        switch (type) {
+        case IRQ_TYPE_EDGE_FALLING:
+        case IRQ_TYPE_EDGE_RISING:
+                good_handle = handle_edge_irq;
+                break;
+        default:
+                good_handle = handle_level_irq;
+        }
+
+        set_irq_chip_and_handler(virq, good_irqchip, good_handle);
+
+        pr_debug("%s: virq=%x, hw=%x. type=%x\n", __func__, virq,
+                 (int)irq, type);
+
+        return 0;
+}
+
+static struct irq_host_ops mpc52xx_irqhost_ops = {
+        .match = mpc52xx_irqhost_match,
+        .xlate = mpc52xx_irqhost_xlate,
+        .map = mpc52xx_irqhost_map,
+};
+
+/*
+ * init (public)
+*/
+
+void __init mpc52xx_init_irq(void)
+{
+        u32 intr_ctrl;
+        struct device_node *picnode;
+
+        /* Remap the necessary zones */
+        picnode = of_find_compatible_node(NULL, NULL, "mpc52xx-pic");
+
+        intr = mpc52xx_find_and_map("mpc52xx-pic");
+        if (!intr)
+                panic(__FILE__  ": find_and_map failed on 'mpc52xx-pic'. "
+                                "Check node !");
+
+        sdma = mpc52xx_find_and_map("mpc52xx-bestcomm");
+        if (!sdma)
+                panic(__FILE__  ": find_and_map failed on 'mpc52xx-bestcomm'. "
+                                "Check node !");
+
+        /* Disable all interrupt sources. */
+        out_be32(&sdma->IntPend, 0xffffffff);   /* 1 means clear pending */
+        out_be32(&sdma->IntMask, 0xffffffff);   /* 1 means disabled */
+        out_be32(&intr->per_mask, 0x7ffffc00);  /* 1 means disabled */
+        out_be32(&intr->main_mask, 0x00010fff); /* 1 means disabled */
+        intr_ctrl = in_be32(&intr->ctrl);
+        intr_ctrl &= 0x00ff0000;        /* Keeps IRQ[0-3] config */
+        intr_ctrl |=    0x0f000000 |    /* clear IRQ 0-3 */
+                        0x00001000 |    /* MEE master external enable */
+                        0x00000000 |    /* 0 means disable IRQ 0-3 */
+                        0x00000001;     /* CEb route critical normally */
+        out_be32(&intr->ctrl, intr_ctrl);
+
+        /* Zero a bunch of the priority settings. */
+        out_be32(&intr->per_pri1, 0);
+        out_be32(&intr->per_pri2, 0);
+        out_be32(&intr->per_pri3, 0);
+        out_be32(&intr->main_pri1, 0);
+        out_be32(&intr->main_pri2, 0);
+
+        /*
+         * As last step, add an irq host to translate the real
+         * hw irq information provided by the ofw to linux virq
+         */
+
+        mpc52xx_irqhost = irq_alloc_host(IRQ_HOST_MAP_LINEAR,
+                                         MPC52xx_IRQ_HIGHTESTHWIRQ,
+                                         &mpc52xx_irqhost_ops, -1);
+
+        if (!mpc52xx_irqhost)
+                panic(__FILE__ ": Cannot allocate the IRQ host\n");
+
+        mpc52xx_irqhost->host_data = picnode;
+        printk(KERN_INFO "MPC52xx PIC is up and running!\n");
+}
+
+/*
+ * get_irq (public)
+*/
+unsigned int mpc52xx_get_irq(void)
+{
+        u32 status;
+        int irq = NO_IRQ_IGNORE;
+
+        status = in_be32(&intr->enc_status);
+        if (status & 0x00000400) {      /* critical */
+                irq = (status >> 8) & 0x3;
+                if (irq == 2)   /* high priority peripheral */
+                        goto peripheral;
+                irq |=  (MPC52xx_IRQ_L1_CRIT << MPC52xx_IRQ_L1_OFFSET) &
+                        MPC52xx_IRQ_L1_MASK;
+        } else if (status & 0x00200000) {       /* main */
+                irq = (status >> 16) & 0x1f;
+                if (irq == 4)   /* low priority peripheral */
+                        goto peripheral;
+                irq |=  (MPC52xx_IRQ_L1_MAIN << MPC52xx_IRQ_L1_OFFSET) &
+                        MPC52xx_IRQ_L1_MASK;
+        } else if (status & 0x20000000) {       /* peripheral */
+              peripheral:
+                irq = (status >> 24) & 0x1f;
+                if (irq == 0) { /* bestcomm */
+                        status = in_be32(&sdma->IntPend);
+                        irq = ffs(status) - 1;
+                        irq |=  (MPC52xx_IRQ_L1_SDMA << MPC52xx_IRQ_L1_OFFSET) &
+                                MPC52xx_IRQ_L1_MASK;
+                } else {
+                        irq |=  (MPC52xx_IRQ_L1_PERP << MPC52xx_IRQ_L1_OFFSET) &
+                                MPC52xx_IRQ_L1_MASK;
+                }
+        }
+
+        pr_debug("%s: irq=%x. virq=%d\n", __func__, irq,
+                 irq_linear_revmap(mpc52xx_irqhost, irq));
+
+        return irq_linear_revmap(mpc52xx_irqhost, irq);
+}
diff --git a/arch/powerpc/platforms/52xx/mpc52xx_pic.h b/arch/powerpc/platforms/52xx/mpc52xx_pic.h
new file mode 100644
index 000000000000..1a26bcdb3049
--- /dev/null
+++ b/arch/powerpc/platforms/52xx/mpc52xx_pic.h
@@ -0,0 +1,53 @@
+/*
+ * Header file for Freescale MPC52xx Interrupt controller
+ *
+ * Copyright (C) 2004-2005 Sylvain Munaut <tnt@246tNt.com>
+ * Copyright (C) 2003 MontaVista, Software, Inc.
+ *
+ * This file is licensed under the terms of the GNU General Public License
+ * version 2. This program is licensed "as is" without any warranty of any
+ * kind, whether express or implied.
+ */
+
+#ifndef __POWERPC_SYSDEV_MPC52xx_PIC_H__
+#define __POWERPC_SYSDEV_MPC52xx_PIC_H__
+
+#include <asm/types.h>
+
+
+/* HW IRQ mapping */
+#define MPC52xx_IRQ_L1_CRIT     (0)
+#define MPC52xx_IRQ_L1_MAIN     (1)
+#define MPC52xx_IRQ_L1_PERP     (2)
+#define MPC52xx_IRQ_L1_SDMA     (3)
+
+#define MPC52xx_IRQ_L1_OFFSET   (6)
+#define MPC52xx_IRQ_L1_MASK     (0x00c0)
+
+#define MPC52xx_IRQ_L2_OFFSET   (0)
+#define MPC52xx_IRQ_L2_MASK     (0x003f)
+
+#define MPC52xx_IRQ_HIGHTESTHWIRQ (0xd0)
+
+
+/* Interrupt controller Register set */
+struct mpc52xx_intr {
+        u32 per_mask;           /* INTR + 0x00 */
+        u32 per_pri1;           /* INTR + 0x04 */
+        u32 per_pri2;           /* INTR + 0x08 */
+        u32 per_pri3;           /* INTR + 0x0c */
+        u32 ctrl;               /* INTR + 0x10 */
+        u32 main_mask;          /* INTR + 0x14 */
+        u32 main_pri1;          /* INTR + 0x18 */
+        u32 main_pri2;          /* INTR + 0x1c */
+        u32 reserved1;          /* INTR + 0x20 */
+        u32 enc_status;         /* INTR + 0x24 */
+        u32 crit_status;        /* INTR + 0x28 */
+        u32 main_status;        /* INTR + 0x2c */
+        u32 per_status;         /* INTR + 0x30 */
+        u32 reserved2;          /* INTR + 0x34 */
+        u32 per_error;          /* INTR + 0x38 */
+};
+
+#endif /* __POWERPC_SYSDEV_MPC52xx_PIC_H__ */
+
diff --git a/arch/powerpc/platforms/82xx/mpc82xx_ads.c b/arch/powerpc/platforms/82xx/mpc82xx_ads.c
index bb9acbb98176..ea880f1f0dcd 100644
--- a/arch/powerpc/platforms/82xx/mpc82xx_ads.c
+++ b/arch/powerpc/platforms/82xx/mpc82xx_ads.c
@@ -515,16 +515,6 @@ static int m82xx_pci_exclude_device(u_char bus, u_char devfn)
                 return PCIBIOS_SUCCESSFUL;
 }
 
-static void
-__init mpc82xx_pcibios_fixup(void)
-{
-        struct pci_dev *dev = NULL;
-
-        for_each_pci_dev(dev) {
-                pci_read_irq_line(dev);
-        }
-}
-
 void __init add_bridge(struct device_node *np)
 {
         int len;
@@ -597,9 +587,6 @@ static void __init mpc82xx_ads_setup_arch(void)
                 add_bridge(np);
 
         of_node_put(np);
-        ppc_md.pci_map_irq = NULL;
-        ppc_md.pcibios_fixup = mpc82xx_pcibios_fixup;
-        ppc_md.pcibios_fixup_bus = NULL;
 #endif
 
 #ifdef  CONFIG_ROOT_NFS
diff --git a/arch/powerpc/platforms/83xx/Kconfig b/arch/powerpc/platforms/83xx/Kconfig
index 7edb6b461382..edcd5b875b66 100644
--- a/arch/powerpc/platforms/83xx/Kconfig
+++ b/arch/powerpc/platforms/83xx/Kconfig
@@ -21,7 +21,7 @@ config MPC834x_SYS
           Be aware that PCI buses can only function when SYS board is plugged
           into the PIB (Platform IO Board) board from Freescale which provide
           3 PCI slots.  The PIBs PCI initialization is the bootloader's
-          responsiblilty.
+          responsibility.
 
 config MPC834x_ITX
         bool "Freescale MPC834x ITX"
@@ -30,7 +30,7 @@ config MPC834x_ITX
           This option enables support for the MPC 834x ITX evaluation board.
 
           Be aware that PCI initialization is the bootloader's
-          responsiblilty.
+          responsibility.
 
 config MPC8360E_PB
         bool "Freescale MPC8360E PB"
diff --git a/arch/powerpc/platforms/83xx/mpc832x_mds.c b/arch/powerpc/platforms/83xx/mpc832x_mds.c
index a43ac71ab740..f58c9780b66f 100644
--- a/arch/powerpc/platforms/83xx/mpc832x_mds.c
+++ b/arch/powerpc/platforms/83xx/mpc832x_mds.c
@@ -97,8 +97,6 @@ static void __init mpc832x_sys_setup_arch(void)
 #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_exclude_device = mpc83xx_exclude_device;
 #endif
 
diff --git a/arch/powerpc/platforms/83xx/mpc834x_itx.c b/arch/powerpc/platforms/83xx/mpc834x_itx.c
index e2bcaaf6b329..314c42ac6048 100644
--- a/arch/powerpc/platforms/83xx/mpc834x_itx.c
+++ b/arch/powerpc/platforms/83xx/mpc834x_itx.c
@@ -118,7 +118,4 @@ define_machine(mpc834x_itx) {
         .time_init              = mpc83xx_time_init,
         .calibrate_decr         = generic_calibrate_decr,
         .progress               = udbg_progress,
-#ifdef CONFIG_PCI
-        .pcibios_fixup          = mpc83xx_pcibios_fixup,
-#endif
 };
diff --git a/arch/powerpc/platforms/83xx/mpc834x_sys.c b/arch/powerpc/platforms/83xx/mpc834x_sys.c
index 677196187a4e..80b735a414d9 100644
--- a/arch/powerpc/platforms/83xx/mpc834x_sys.c
+++ b/arch/powerpc/platforms/83xx/mpc834x_sys.c
@@ -137,7 +137,4 @@ define_machine(mpc834x_sys) {
         .time_init              = mpc83xx_time_init,
         .calibrate_decr         = generic_calibrate_decr,
         .progress               = udbg_progress,
-#ifdef CONFIG_PCI
-        .pcibios_fixup          = mpc83xx_pcibios_fixup,
-#endif
 };
diff --git a/arch/powerpc/platforms/83xx/mpc8360e_pb.c b/arch/powerpc/platforms/83xx/mpc8360e_pb.c
index 1a523c81c06e..7bfd47ad7233 100644
--- a/arch/powerpc/platforms/83xx/mpc8360e_pb.c
+++ b/arch/powerpc/platforms/83xx/mpc8360e_pb.c
@@ -102,8 +102,6 @@ static void __init mpc8360_sys_setup_arch(void)
 #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_exclude_device = mpc83xx_exclude_device;
 #endif
 
diff --git a/arch/powerpc/platforms/83xx/mpc83xx.h b/arch/powerpc/platforms/83xx/mpc83xx.h
index 2c82bca9bfbb..01cae106912b 100644
--- a/arch/powerpc/platforms/83xx/mpc83xx.h
+++ b/arch/powerpc/platforms/83xx/mpc83xx.h
@@ -11,7 +11,6 @@
 
 extern int add_bridge(struct device_node *dev);
 extern int mpc83xx_exclude_device(u_char bus, u_char devfn);
-extern void mpc83xx_pcibios_fixup(void);
 extern void mpc83xx_restart(char *cmd);
 extern long mpc83xx_time_init(void);
 
diff --git a/arch/powerpc/platforms/83xx/pci.c b/arch/powerpc/platforms/83xx/pci.c
index 4557ac5255c1..9c3650555144 100644
--- a/arch/powerpc/platforms/83xx/pci.c
+++ b/arch/powerpc/platforms/83xx/pci.c
@@ -45,15 +45,6 @@ int mpc83xx_exclude_device(u_char bus, u_char devfn)
         return PCIBIOS_SUCCESSFUL;
 }
 
-void __init mpc83xx_pcibios_fixup(void)
-{
-        struct pci_dev *dev = NULL;
-
-        /* map all the PCI irqs */
-        for_each_pci_dev(dev)
-                pci_read_irq_line(dev);
-}
-
 int __init add_bridge(struct device_node *dev)
 {
         int len;
diff --git a/arch/powerpc/platforms/85xx/misc.c b/arch/powerpc/platforms/85xx/misc.c
index 26c5e822c7c8..3e62fcb04c1c 100644
--- a/arch/powerpc/platforms/85xx/misc.c
+++ b/arch/powerpc/platforms/85xx/misc.c
@@ -21,11 +21,3 @@ void mpc85xx_restart(char *cmd)
         local_irq_disable();
         abort();
 }
-
-/* For now this is a pass through */
-phys_addr_t fixup_bigphys_addr(phys_addr_t addr, phys_addr_t size)
-{
-        return addr;
-};
-
-EXPORT_SYMBOL(fixup_bigphys_addr);
diff --git a/arch/powerpc/platforms/85xx/mpc85xx_ads.c b/arch/powerpc/platforms/85xx/mpc85xx_ads.c
index d3e669d69c73..bda2e55e6c4c 100644
--- a/arch/powerpc/platforms/85xx/mpc85xx_ads.c
+++ b/arch/powerpc/platforms/85xx/mpc85xx_ads.c
@@ -53,15 +53,6 @@ mpc85xx_exclude_device(u_char bus, u_char devfn)
         else
                 return PCIBIOS_SUCCESSFUL;
 }
-
-void __init
-mpc85xx_pcibios_fixup(void)
-{
-        struct pci_dev *dev = NULL;
-
-        for_each_pci_dev(dev)
-                pci_read_irq_line(dev);
-}
 #endif /* CONFIG_PCI */
 
 #ifdef CONFIG_CPM2
@@ -253,8 +244,6 @@ static void __init mpc85xx_ads_setup_arch(void)
 #ifdef CONFIG_PCI
         for (np = NULL; (np = of_find_node_by_type(np, "pci")) != NULL;)
                 add_bridge(np);
-
-        ppc_md.pcibios_fixup = mpc85xx_pcibios_fixup;
         ppc_md.pci_exclude_device = mpc85xx_exclude_device;
 #endif
 
diff --git a/arch/powerpc/platforms/86xx/mpc86xx_hpcn.c b/arch/powerpc/platforms/86xx/mpc86xx_hpcn.c
index 1a1c226ad4d9..f4dd5f2f8a28 100644
--- a/arch/powerpc/platforms/86xx/mpc86xx_hpcn.c
+++ b/arch/powerpc/platforms/86xx/mpc86xx_hpcn.c
@@ -398,15 +398,6 @@ mpc86xx_hpcn_show_cpuinfo(struct seq_file *m)
 }
 
 
-void __init mpc86xx_hpcn_pcibios_fixup(void)
-{
-        struct pci_dev *dev = NULL;
-
-        for_each_pci_dev(dev)
-                pci_read_irq_line(dev);
-}
-
-
 /*
  * Called very early, device-tree isn't unflattened
  */
@@ -461,7 +452,6 @@ define_machine(mpc86xx_hpcn) {
         .setup_arch             = mpc86xx_hpcn_setup_arch,
         .init_IRQ               = mpc86xx_hpcn_init_irq,
         .show_cpuinfo           = mpc86xx_hpcn_show_cpuinfo,
-        .pcibios_fixup          = mpc86xx_hpcn_pcibios_fixup,
         .get_irq                = mpic_get_irq,
         .restart                = mpc86xx_restart,
         .time_init              = mpc86xx_time_init,
diff --git a/arch/powerpc/platforms/Makefile b/arch/powerpc/platforms/Makefile
index e58fa953a50b..507d1b98f270 100644
--- a/arch/powerpc/platforms/Makefile
+++ b/arch/powerpc/platforms/Makefile
@@ -5,6 +5,7 @@ ifeq ($(CONFIG_PPC64),y)
 obj-$(CONFIG_PPC_PMAC)          += powermac/
 endif
 endif
+obj-$(CONFIG_PPC_MPC52xx)       += 52xx/
 obj-$(CONFIG_PPC_CHRP)          += chrp/
 obj-$(CONFIG_4xx)               += 4xx/
 obj-$(CONFIG_PPC_83xx)          += 83xx/
@@ -13,6 +14,7 @@ obj-$(CONFIG_PPC_86xx)		+= 86xx/
 obj-$(CONFIG_PPC_PSERIES)       += pseries/
 obj-$(CONFIG_PPC_ISERIES)       += iseries/
 obj-$(CONFIG_PPC_MAPLE)         += maple/
-obj-$(CONFIG_PPC_PASEMI)                += pasemi/
+obj-$(CONFIG_PPC_PASEMI)        += pasemi/
 obj-$(CONFIG_PPC_CELL)          += cell/
+obj-$(CONFIG_PPC_PS3)           += ps3/
 obj-$(CONFIG_EMBEDDED6xx)       += embedded6xx/
diff --git a/arch/powerpc/platforms/cell/Kconfig b/arch/powerpc/platforms/cell/Kconfig
index 3e430b489bb7..06a85b704331 100644
--- a/arch/powerpc/platforms/cell/Kconfig
+++ b/arch/powerpc/platforms/cell/Kconfig
@@ -20,4 +20,18 @@ config CBE_RAS
         bool "RAS features for bare metal Cell BE"
         default y
 
+config CBE_THERM
+        tristate "CBE thermal support"
+        default m
+        depends on CBE_RAS
+
+config CBE_CPUFREQ
+        tristate "CBE frequency scaling"
+        depends on CBE_RAS && CPU_FREQ
+        default m
+        help
+          This adds the cpufreq driver for Cell BE processors.
+          For details, take a look at <file:Documentation/cpu-freq/>.
+          If you don't have such processor, say N
+
 endmenu
diff --git a/arch/powerpc/platforms/cell/Makefile b/arch/powerpc/platforms/cell/Makefile
index c89cdd67383b..f90e8337796c 100644
--- a/arch/powerpc/platforms/cell/Makefile
+++ b/arch/powerpc/platforms/cell/Makefile
@@ -1,7 +1,11 @@
 obj-$(CONFIG_PPC_CELL_NATIVE)           += interrupt.o iommu.o setup.o \
-                                           cbe_regs.o spider-pic.o pervasive.o
+                                           cbe_regs.o spider-pic.o \
+                                           pervasive.o pmu.o io-workarounds.o
 obj-$(CONFIG_CBE_RAS)                   += ras.o
 
+obj-$(CONFIG_CBE_THERM)                 += cbe_thermal.o
+obj-$(CONFIG_CBE_CPUFREQ)               += cbe_cpufreq.o
+
 ifeq ($(CONFIG_SMP),y)
 obj-$(CONFIG_PPC_CELL_NATIVE)           += smp.o
 endif
@@ -11,5 +15,6 @@ 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 \
+                                           spu_coredump.o \
                                            $(spufs-modular-m) \
                                            $(spu-priv1-y) spufs/
diff --git a/arch/powerpc/platforms/cell/cbe_cpufreq.c b/arch/powerpc/platforms/cell/cbe_cpufreq.c
new file mode 100644
index 000000000000..a3850fd1e94c
--- /dev/null
+++ b/arch/powerpc/platforms/cell/cbe_cpufreq.c
@@ -0,0 +1,248 @@
+/*
+ * cpufreq driver for the cell processor
+ *
+ * (C) Copyright IBM Deutschland Entwicklung GmbH 2005
+ *
+ * Author: Christian Krafft <krafft@de.ibm.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <linux/cpufreq.h>
+#include <linux/timer.h>
+
+#include <asm/hw_irq.h>
+#include <asm/io.h>
+#include <asm/processor.h>
+#include <asm/prom.h>
+#include <asm/time.h>
+
+#include "cbe_regs.h"
+
+static DEFINE_MUTEX(cbe_switch_mutex);
+
+
+/* the CBE supports an 8 step frequency scaling */
+static struct cpufreq_frequency_table cbe_freqs[] = {
+        {1,     0},
+        {2,     0},
+        {3,     0},
+        {4,     0},
+        {5,     0},
+        {6,     0},
+        {8,     0},
+        {10,    0},
+        {0,     CPUFREQ_TABLE_END},
+};
+
+/* to write to MIC register */
+static u64 MIC_Slow_Fast_Timer_table[] = {
+        [0 ... 7] = 0x007fc00000000000ull,
+};
+
+/* more values for the MIC */
+static u64 MIC_Slow_Next_Timer_table[] = {
+        0x0000240000000000ull,
+        0x0000268000000000ull,
+        0x000029C000000000ull,
+        0x00002D0000000000ull,
+        0x0000300000000000ull,
+        0x0000334000000000ull,
+        0x000039C000000000ull,
+        0x00003FC000000000ull,
+};
+
+/*
+ * hardware specific functions
+ */
+
+static int get_pmode(int cpu)
+{
+        int ret;
+        struct cbe_pmd_regs __iomem *pmd_regs;
+
+        pmd_regs = cbe_get_cpu_pmd_regs(cpu);
+        ret = in_be64(&pmd_regs->pmsr) & 0x07;
+
+        return ret;
+}
+
+static int set_pmode(int cpu, unsigned int pmode)
+{
+        struct cbe_pmd_regs __iomem *pmd_regs;
+        struct cbe_mic_tm_regs __iomem *mic_tm_regs;
+        u64 flags;
+        u64 value;
+
+        local_irq_save(flags);
+
+        mic_tm_regs = cbe_get_cpu_mic_tm_regs(cpu);
+        pmd_regs = cbe_get_cpu_pmd_regs(cpu);
+
+        pr_debug("pm register is mapped at %p\n", &pmd_regs->pmcr);
+        pr_debug("mic register is mapped at %p\n", &mic_tm_regs->slow_fast_timer_0);
+
+        out_be64(&mic_tm_regs->slow_fast_timer_0, MIC_Slow_Fast_Timer_table[pmode]);
+        out_be64(&mic_tm_regs->slow_fast_timer_1, MIC_Slow_Fast_Timer_table[pmode]);
+
+        out_be64(&mic_tm_regs->slow_next_timer_0, MIC_Slow_Next_Timer_table[pmode]);
+        out_be64(&mic_tm_regs->slow_next_timer_1, MIC_Slow_Next_Timer_table[pmode]);
+
+        value = in_be64(&pmd_regs->pmcr);
+        /* set bits to zero */
+        value &= 0xFFFFFFFFFFFFFFF8ull;
+        /* set bits to next pmode */
+        value |= pmode;
+
+        out_be64(&pmd_regs->pmcr, value);
+
+        /* wait until new pmode appears in status register */
+        value = in_be64(&pmd_regs->pmsr) & 0x07;
+        while(value != pmode) {
+                cpu_relax();
+                value = in_be64(&pmd_regs->pmsr) & 0x07;
+        }
+
+        local_irq_restore(flags);
+
+        return 0;
+}
+
+/*
+ * cpufreq functions
+ */
+
+static int cbe_cpufreq_cpu_init (struct cpufreq_policy *policy)
+{
+        u32 *max_freq;
+        int i, cur_pmode;
+        struct device_node *cpu;
+
+        cpu = of_get_cpu_node(policy->cpu, NULL);
+
+        if(!cpu)
+                return -ENODEV;
+
+        pr_debug("init cpufreq on CPU %d\n", policy->cpu);
+
+        max_freq = (u32*) get_property(cpu, "clock-frequency", NULL);
+
+        if(!max_freq)
+                return -EINVAL;
+
+        // we need the freq in kHz
+        *max_freq /= 1000;
+
+        pr_debug("max clock-frequency is at %u kHz\n", *max_freq);
+        pr_debug("initializing frequency table\n");
+
+        // initialize frequency table
+        for (i=0; cbe_freqs[i].frequency!=CPUFREQ_TABLE_END; i++) {
+                cbe_freqs[i].frequency = *max_freq / cbe_freqs[i].index;
+                pr_debug("%d: %d\n", i, cbe_freqs[i].frequency);
+        }
+
+        policy->governor = CPUFREQ_DEFAULT_GOVERNOR;
+        /* if DEBUG is enabled set_pmode() measures the correct latency of a transition */
+        policy->cpuinfo.transition_latency = 25000;
+
+        cur_pmode = get_pmode(policy->cpu);
+        pr_debug("current pmode is at %d\n",cur_pmode);
+
+        policy->cur = cbe_freqs[cur_pmode].frequency;
+
+#ifdef CONFIG_SMP
+        policy->cpus = cpu_sibling_map[policy->cpu];
+#endif
+
+        cpufreq_frequency_table_get_attr (cbe_freqs, policy->cpu);
+
+        /* this ensures that policy->cpuinfo_min and policy->cpuinfo_max are set correctly */
+        return cpufreq_frequency_table_cpuinfo (policy, cbe_freqs);
+}
+
+static int cbe_cpufreq_cpu_exit(struct cpufreq_policy *policy)
+{
+        cpufreq_frequency_table_put_attr(policy->cpu);
+        return 0;
+}
+
+static int cbe_cpufreq_verify(struct cpufreq_policy *policy)
+{
+        return cpufreq_frequency_table_verify(policy, cbe_freqs);
+}
+
+
+static int cbe_cpufreq_target(struct cpufreq_policy *policy, unsigned int target_freq,
+                            unsigned int relation)
+{
+        int rc;
+        struct cpufreq_freqs freqs;
+        int cbe_pmode_new;
+
+        cpufreq_frequency_table_target(policy,
+                                       cbe_freqs,
+                                       target_freq,
+                                       relation,
+                                       &cbe_pmode_new);
+
+        freqs.old = policy->cur;
+        freqs.new = cbe_freqs[cbe_pmode_new].frequency;
+        freqs.cpu = policy->cpu;
+
+        mutex_lock (&cbe_switch_mutex);
+        cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
+
+        pr_debug("setting frequency for cpu %d to %d kHz, 1/%d of max frequency\n",
+                 policy->cpu,
+                 cbe_freqs[cbe_pmode_new].frequency,
+                 cbe_freqs[cbe_pmode_new].index);
+
+        rc = set_pmode(policy->cpu, cbe_pmode_new);
+        cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
+        mutex_unlock(&cbe_switch_mutex);
+
+        return rc;
+}
+
+static struct cpufreq_driver cbe_cpufreq_driver = {
+        .verify         = cbe_cpufreq_verify,
+        .target         = cbe_cpufreq_target,
+        .init           = cbe_cpufreq_cpu_init,
+        .exit           = cbe_cpufreq_cpu_exit,
+        .name           = "cbe-cpufreq",
+        .owner          = THIS_MODULE,
+        .flags          = CPUFREQ_CONST_LOOPS,
+};
+
+/*
+ * module init and destoy
+ */
+
+static int __init cbe_cpufreq_init(void)
+{
+        return cpufreq_register_driver(&cbe_cpufreq_driver);
+}
+
+static void __exit cbe_cpufreq_exit(void)
+{
+        cpufreq_unregister_driver(&cbe_cpufreq_driver);
+}
+
+module_init(cbe_cpufreq_init);
+module_exit(cbe_cpufreq_exit);
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Christian Krafft <krafft@de.ibm.com>");
diff --git a/arch/powerpc/platforms/cell/cbe_regs.c b/arch/powerpc/platforms/cell/cbe_regs.c
index 2f194ba29899..9a0ee62691d5 100644
--- a/arch/powerpc/platforms/cell/cbe_regs.c
+++ b/arch/powerpc/platforms/cell/cbe_regs.c
@@ -8,6 +8,7 @@
 
 #include <linux/percpu.h>
 #include <linux/types.h>
+#include <linux/module.h>
 
 #include <asm/io.h>
 #include <asm/pgtable.h>
@@ -16,8 +17,6 @@
 
 #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
@@ -30,6 +29,8 @@ static struct cbe_regs_map
         struct device_node *cpu_node;
         struct cbe_pmd_regs __iomem *pmd_regs;
         struct cbe_iic_regs __iomem *iic_regs;
+        struct cbe_mic_tm_regs __iomem *mic_tm_regs;
+        struct cbe_pmd_shadow_regs pmd_shadow_regs;
 } cbe_regs_maps[MAX_CBE];
 static int cbe_regs_map_count;
 
@@ -42,6 +43,19 @@ static struct cbe_thread_map
 static struct cbe_regs_map *cbe_find_map(struct device_node *np)
 {
         int i;
+        struct device_node *tmp_np;
+
+        if (strcasecmp(np->type, "spe") == 0) {
+                if (np->data == NULL) {
+                        /* walk up path until cpu node was found */
+                        tmp_np = np->parent;
+                        while (tmp_np != NULL && strcasecmp(tmp_np->type, "cpu") != 0)
+                                tmp_np = tmp_np->parent;
+
+                        np->data = cbe_find_map(tmp_np);
+                }
+                return np->data;
+        }
 
         for (i = 0; i < cbe_regs_map_count; i++)
                 if (cbe_regs_maps[i].cpu_node == np)
@@ -56,6 +70,7 @@ struct cbe_pmd_regs __iomem *cbe_get_pmd_regs(struct device_node *np)
                 return NULL;
         return map->pmd_regs;
 }
+EXPORT_SYMBOL_GPL(cbe_get_pmd_regs);
 
 struct cbe_pmd_regs __iomem *cbe_get_cpu_pmd_regs(int cpu)
 {
@@ -64,7 +79,23 @@ struct cbe_pmd_regs __iomem *cbe_get_cpu_pmd_regs(int cpu)
                 return NULL;
         return map->pmd_regs;
 }
+EXPORT_SYMBOL_GPL(cbe_get_cpu_pmd_regs);
 
+struct cbe_pmd_shadow_regs *cbe_get_pmd_shadow_regs(struct device_node *np)
+{
+        struct cbe_regs_map *map = cbe_find_map(np);
+        if (map == NULL)
+                return NULL;
+        return &map->pmd_shadow_regs;
+}
+
+struct cbe_pmd_shadow_regs *cbe_get_cpu_pmd_shadow_regs(int cpu)
+{
+        struct cbe_regs_map *map = cbe_thread_map[cpu].regs;
+        if (map == NULL)
+                return NULL;
+        return &map->pmd_shadow_regs;
+}
 
 struct cbe_iic_regs __iomem *cbe_get_iic_regs(struct device_node *np)
 {
@@ -73,6 +104,7 @@ struct cbe_iic_regs __iomem *cbe_get_iic_regs(struct device_node *np)
                 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;
@@ -81,6 +113,36 @@ struct cbe_iic_regs __iomem *cbe_get_cpu_iic_regs(int cpu)
         return map->iic_regs;
 }
 
+struct cbe_mic_tm_regs __iomem *cbe_get_mic_tm_regs(struct device_node *np)
+{
+        struct cbe_regs_map *map = cbe_find_map(np);
+        if (map == NULL)
+                return NULL;
+        return map->mic_tm_regs;
+}
+
+struct cbe_mic_tm_regs __iomem *cbe_get_cpu_mic_tm_regs(int cpu)
+{
+        struct cbe_regs_map *map = cbe_thread_map[cpu].regs;
+        if (map == NULL)
+                return NULL;
+        return map->mic_tm_regs;
+}
+EXPORT_SYMBOL_GPL(cbe_get_cpu_mic_tm_regs);
+
+/* FIXME
+ * This is little more than a stub at the moment.  It should be
+ * fleshed out so that it works for both SMT and non-SMT, no
+ * matter if the passed cpu is odd or even.
+ * For SMT enabled, returns 0 for even-numbered cpu; otherwise 1.
+ * For SMT disabled, returns 0 for all cpus.
+ */
+u32 cbe_get_hw_thread_id(int cpu)
+{
+        return (cpu & 1);
+}
+EXPORT_SYMBOL_GPL(cbe_get_hw_thread_id);
+
 void __init cbe_regs_init(void)
 {
         int i;
@@ -119,6 +181,11 @@ void __init cbe_regs_init(void)
                 prop = get_property(cpu, "iic", NULL);
                 if (prop != NULL)
                         map->iic_regs = ioremap(prop->address, prop->len);
+
+                prop = (struct address_prop *)get_property(cpu, "mic-tm",
+                                                           NULL);
+                if (prop != NULL)
+                        map->mic_tm_regs = ioremap(prop->address, prop->len);
         }
 }
 
diff --git a/arch/powerpc/platforms/cell/cbe_regs.h b/arch/powerpc/platforms/cell/cbe_regs.h
index e76e4a6af5bc..440a7ecc66ea 100644
--- a/arch/powerpc/platforms/cell/cbe_regs.h
+++ b/arch/powerpc/platforms/cell/cbe_regs.h
@@ -4,12 +4,19 @@
  * This file is intended to hold the various register definitions for CBE
  * on-chip system devices (memory controller, IO controller, etc...)
  *
+ * (C) Copyright IBM Corporation 2001,2006
+ *
+ * Authors: Maximino Aguilar (maguilar@us.ibm.com)
+ *          David J. Erb (djerb@us.ibm.com)
+ *
  * (c) 2006 Benjamin Herrenschmidt <benh@kernel.crashing.org>, IBM Corp.
  */
 
 #ifndef CBE_REGS_H
 #define CBE_REGS_H
 
+#include <asm/cell-pmu.h>
+
 /*
  *
  * Some HID register definitions
@@ -22,6 +29,7 @@
 #define HID0_CBE_THERM_INT_EN   0x0000000400000000ul
 #define HID0_CBE_SYSERR_INT_EN  0x0000000200000000ul
 
+#define MAX_CBE         2
 
 /*
  *
@@ -29,51 +37,124 @@
  *
  */
 
+union spe_reg {
+        u64 val;
+        u8 spe[8];
+};
+
+union ppe_spe_reg {
+        u64 val;
+        struct {
+                u32 ppe;
+                u32 spe;
+        };
+};
+
+
 struct cbe_pmd_regs {
-        u8 pad_0x0000_0x0800[0x0800 - 0x0000];                  /* 0x0000 */
+        /* Debug Bus Control */
+        u64     pad_0x0000;                                     /* 0x0000 */
+
+        u64     group_control;                                  /* 0x0008 */
+
+        u8      pad_0x0010_0x00a8 [0x00a8 - 0x0010];            /* 0x0010 */
+
+        u64     debug_bus_control;                              /* 0x00a8 */
+
+        u8      pad_0x00b0_0x0100 [0x0100 - 0x00b0];            /* 0x00b0 */
+
+        u64     trace_aux_data;                                 /* 0x0100 */
+        u64     trace_buffer_0_63;                              /* 0x0108 */
+        u64     trace_buffer_64_127;                            /* 0x0110 */
+        u64     trace_address;                                  /* 0x0118 */
+        u64     ext_tr_timer;                                   /* 0x0120 */
+
+        u8      pad_0x0128_0x0400 [0x0400 - 0x0128];            /* 0x0128 */
+
+        /* Performance Monitor */
+        u64     pm_status;                                      /* 0x0400 */
+        u64     pm_control;                                     /* 0x0408 */
+        u64     pm_interval;                                    /* 0x0410 */
+        u64     pm_ctr[4];                                      /* 0x0418 */
+        u64     pm_start_stop;                                  /* 0x0438 */
+        u64     pm07_control[8];                                /* 0x0440 */
+
+        u8      pad_0x0480_0x0800 [0x0800 - 0x0480];            /* 0x0480 */
 
         /* 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 */
+        union   spe_reg ts_ctsr1;                               /* 0x0800 */
+        u64     ts_ctsr2;                                       /* 0x0808 */
+        union   spe_reg ts_mtsr1;                               /* 0x0810 */
+        u64     ts_mtsr2;                                       /* 0x0818 */
+        union   spe_reg ts_itr1;                                /* 0x0820 */
+        u64     ts_itr2;                                        /* 0x0828 */
+        u64     ts_gitr;                                        /* 0x0830 */
+        u64     ts_isr;                                         /* 0x0838 */
+        u64     ts_imr;                                         /* 0x0840 */
+        union   spe_reg tm_cr1;                                 /* 0x0848 */
+        u64     tm_cr2;                                         /* 0x0850 */
+        u64     tm_simr;                                        /* 0x0858 */
+        union   ppe_spe_reg tm_tpr;                             /* 0x0860 */
+        union   spe_reg tm_str1;                                /* 0x0868 */
+        u64     tm_str2;                                        /* 0x0870 */
+        union   ppe_spe_reg tm_tsr;                             /* 0x0878 */
 
         /* Power Management */
-        u64  pm_control;                                        /* 0x0880 */
-#define CBE_PMD_PAUSE_ZERO_CONTROL              0x10000
-        u64  pm_status;                                         /* 0x0888 */
+        u64     pmcr;                                           /* 0x0880 */
+#define CBE_PMD_PAUSE_ZERO_CONTROL      0x10000
+        u64     pmsr;                                           /* 0x0888 */
 
         /* Time Base Register */
-        u64  tbr;                                               /* 0x0890 */
+        u64     tbr;                                            /* 0x0890 */
 
-        u8   pad_0x0898_0x0c00 [0x0c00 - 0x0898];               /* 0x0898 */
+        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;
+        u64     checkstop_fir;                                  /* 0x0c00 */
+        u64     recoverable_fir;                                /* 0x0c08 */
+        u64     spec_att_mchk_fir;                              /* 0x0c10 */
+        u64     fir_mode_reg;                                   /* 0x0c18 */
+        u64     fir_enable_mask;                                /* 0x0c20 */
 
-        u8   pad_0x0c28_0x1000 [0x1000 - 0x0c28];               /* 0x0c28 */
+        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);
 
 /*
+ * PMU shadow registers
+ *
+ * Many of the registers in the performance monitoring unit are write-only,
+ * so we need to save a copy of what we write to those registers.
+ *
+ * The actual data counters are read/write. However, writing to the counters
+ * only takes effect if the PMU is enabled. Otherwise the value is stored in
+ * a hardware latch until the next time the PMU is enabled. So we save a copy
+ * of the counter values if we need to read them back while the PMU is
+ * disabled. The counter_value_in_latch field is a bitmap indicating which
+ * counters currently have a value waiting to be written.
+ */
+
+struct cbe_pmd_shadow_regs {
+        u32 group_control;
+        u32 debug_bus_control;
+        u32 trace_address;
+        u32 ext_tr_timer;
+        u32 pm_status;
+        u32 pm_control;
+        u32 pm_interval;
+        u32 pm_start_stop;
+        u32 pm07_control[NR_CTRS];
+
+        u32 pm_ctr[NR_PHYS_CTRS];
+        u32 counter_value_in_latch;
+};
+
+extern struct cbe_pmd_shadow_regs *cbe_get_pmd_shadow_regs(struct device_node *np);
+extern struct cbe_pmd_shadow_regs *cbe_get_cpu_pmd_shadow_regs(int cpu);
+
+/*
  *
  * IIC unit register definitions
  *
@@ -102,18 +183,28 @@ struct cbe_iic_regs {
 
         /* IIC interrupt registers */
         struct  cbe_iic_thread_regs thread[2];                  /* 0x0400 */
-        u64     iic_ir;                                         /* 0x0440 */
-        u64     iic_is;                                         /* 0x0448 */
+
+        u64     iic_ir;                                         /* 0x0440 */
+#define CBE_IIC_IR_PRIO(x)      (((x) & 0xf) << 12)
+#define CBE_IIC_IR_DEST_NODE(x) (((x) & 0xf) << 4)
+#define CBE_IIC_IR_DEST_UNIT(x) ((x) & 0xf)
+#define CBE_IIC_IR_IOC_0        0x0
+#define CBE_IIC_IR_IOC_1S       0xb
+#define CBE_IIC_IR_PT_0         0xe
+#define CBE_IIC_IR_PT_1         0xf
+
+        u64     iic_is;                                         /* 0x0448 */
+#define CBE_IIC_IS_PMI          0x2
 
         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;
+        u64     ioc_fir_set;                                    /* 0x0508 */
+        u64     ioc_checkstop_enable;                           /* 0x0510 */
+        u64     ioc_fir_error_mask;                             /* 0x0518 */
+        u64     ioc_syserr_enable;                              /* 0x0520 */
+        u64     ioc_fir;                                        /* 0x0528 */
 
         u8      pad_0x0530_0x1000[0x1000 - 0x0530];             /* 0x0530 */
 };
@@ -122,6 +213,48 @@ 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);
 
 
+struct cbe_mic_tm_regs {
+        u8      pad_0x0000_0x0040[0x0040 - 0x0000];             /* 0x0000 */
+
+        u64     mic_ctl_cnfg2;                                  /* 0x0040 */
+#define CBE_MIC_ENABLE_AUX_TRC          0x8000000000000000LL
+#define CBE_MIC_DISABLE_PWR_SAV_2       0x0200000000000000LL
+#define CBE_MIC_DISABLE_AUX_TRC_WRAP    0x0100000000000000LL
+#define CBE_MIC_ENABLE_AUX_TRC_INT      0x0080000000000000LL
+
+        u64     pad_0x0048;                                     /* 0x0048 */
+
+        u64     mic_aux_trc_base;                               /* 0x0050 */
+        u64     mic_aux_trc_max_addr;                           /* 0x0058 */
+        u64     mic_aux_trc_cur_addr;                           /* 0x0060 */
+        u64     mic_aux_trc_grf_addr;                           /* 0x0068 */
+        u64     mic_aux_trc_grf_data;                           /* 0x0070 */
+
+        u64     pad_0x0078;                                     /* 0x0078 */
+
+        u64     mic_ctl_cnfg_0;                                 /* 0x0080 */
+#define CBE_MIC_DISABLE_PWR_SAV_0       0x8000000000000000LL
+
+        u64     pad_0x0088;                                     /* 0x0088 */
+
+        u64     slow_fast_timer_0;                              /* 0x0090 */
+        u64     slow_next_timer_0;                              /* 0x0098 */
+
+        u8      pad_0x00a0_0x01c0[0x01c0 - 0x0a0];              /* 0x00a0 */
+
+        u64     mic_ctl_cnfg_1;                                 /* 0x01c0 */
+#define CBE_MIC_DISABLE_PWR_SAV_1       0x8000000000000000LL
+        u64     pad_0x01c8;                                     /* 0x01c8 */
+
+        u64     slow_fast_timer_1;                              /* 0x01d0 */
+        u64     slow_next_timer_1;                              /* 0x01d8 */
+
+        u8      pad_0x01e0_0x1000[0x1000 - 0x01e0];             /* 0x01e0 */
+};
+
+extern struct cbe_mic_tm_regs __iomem *cbe_get_mic_tm_regs(struct device_node *np);
+extern struct cbe_mic_tm_regs __iomem *cbe_get_cpu_mic_tm_regs(int cpu);
+
 /* Init this module early */
 extern void cbe_regs_init(void);
 
diff --git a/arch/powerpc/platforms/cell/cbe_thermal.c b/arch/powerpc/platforms/cell/cbe_thermal.c
new file mode 100644
index 000000000000..70e0d968d30f
--- /dev/null
+++ b/arch/powerpc/platforms/cell/cbe_thermal.c
@@ -0,0 +1,228 @@
+/*
+ * thermal support for the cell processor
+ *
+ * (C) Copyright IBM Deutschland Entwicklung GmbH 2005
+ *
+ * Author: Christian Krafft <krafft@de.ibm.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <linux/module.h>
+#include <linux/sysdev.h>
+#include <linux/kernel.h>
+#include <linux/cpu.h>
+#include <asm/spu.h>
+#include <asm/io.h>
+#include <asm/prom.h>
+
+#include "cbe_regs.h"
+#include "spu_priv1_mmio.h"
+
+static struct cbe_pmd_regs __iomem *get_pmd_regs(struct sys_device *sysdev)
+{
+        struct spu *spu;
+
+        spu = container_of(sysdev, struct spu, sysdev);
+
+        return cbe_get_pmd_regs(spu_devnode(spu));
+}
+
+/* returns the value for a given spu in a given register */
+static u8 spu_read_register_value(struct sys_device *sysdev, union spe_reg __iomem *reg)
+{
+        unsigned int *id;
+        union spe_reg value;
+        struct spu *spu;
+
+        /* getting the id from the reg attribute will not work on future device-tree layouts
+         * in future we should store the id to the spu struct and use it here */
+        spu = container_of(sysdev, struct spu, sysdev);
+        id = (unsigned int *)get_property(spu_devnode(spu), "reg", NULL);
+        value.val = in_be64(&reg->val);
+
+        return value.spe[*id];
+}
+
+static ssize_t spu_show_temp(struct sys_device *sysdev, char *buf)
+{
+        int value;
+        struct cbe_pmd_regs __iomem *pmd_regs;
+
+        pmd_regs = get_pmd_regs(sysdev);
+
+        value = spu_read_register_value(sysdev, &pmd_regs->ts_ctsr1);
+        /* clear all other bits */
+        value &= 0x3F;
+        /* temp is stored in steps of 2 degrees */
+        value *= 2;
+        /* base temp is 65 degrees */
+        value += 65;
+
+        return sprintf(buf, "%d\n", (int) value);
+}
+
+static ssize_t ppe_show_temp(struct sys_device *sysdev, char *buf, int pos)
+{
+        struct cbe_pmd_regs __iomem *pmd_regs;
+        u64 value;
+
+        pmd_regs = cbe_get_cpu_pmd_regs(sysdev->id);
+        value = in_be64(&pmd_regs->ts_ctsr2);
+
+        /* access the corresponding byte */
+        value >>= pos;
+        /* clear all other bits */
+        value &= 0x3F;
+        /* temp is stored in steps of 2 degrees */
+        value *= 2;
+        /* base temp is 65 degrees */
+        value += 65;
+
+        return sprintf(buf, "%d\n", (int) value);
+}
+
+
+/* shows the temperature of the DTS on the PPE,
+ * located near the linear thermal sensor */
+static ssize_t ppe_show_temp0(struct sys_device *sysdev, char *buf)
+{
+        return ppe_show_temp(sysdev, buf, 32);
+}
+
+/* shows the temperature of the second DTS on the PPE */
+static ssize_t ppe_show_temp1(struct sys_device *sysdev, char *buf)
+{
+        return ppe_show_temp(sysdev, buf, 0);
+}
+
+static struct sysdev_attribute attr_spu_temperature = {
+        .attr = {.name = "temperature", .mode = 0400 },
+        .show = spu_show_temp,
+};
+
+static struct attribute *spu_attributes[] = {
+        &attr_spu_temperature.attr,
+        NULL,
+};
+
+static struct attribute_group spu_attribute_group = {
+        .name   = "thermal",
+        .attrs  = spu_attributes,
+};
+
+static struct sysdev_attribute attr_ppe_temperature0 = {
+        .attr = {.name = "temperature0", .mode = 0400 },
+        .show = ppe_show_temp0,
+};
+
+static struct sysdev_attribute attr_ppe_temperature1 = {
+        .attr = {.name = "temperature1", .mode = 0400 },
+        .show = ppe_show_temp1,
+};
+
+static struct attribute *ppe_attributes[] = {
+        &attr_ppe_temperature0.attr,
+        &attr_ppe_temperature1.attr,
+        NULL,
+};
+
+static struct attribute_group ppe_attribute_group = {
+        .name   = "thermal",
+        .attrs  = ppe_attributes,
+};
+
+/*
+ * initialize throttling with default values
+ */
+static void __init init_default_values(void)
+{
+        int cpu;
+        struct cbe_pmd_regs __iomem *pmd_regs;
+        struct sys_device *sysdev;
+        union ppe_spe_reg tpr;
+        union spe_reg str1;
+        u64 str2;
+        union spe_reg cr1;
+        u64 cr2;
+
+        /* TPR defaults */
+        /* ppe
+         *      1F - no full stop
+         *      08 - dynamic throttling starts if over 80 degrees
+         *      03 - dynamic throttling ceases if below 70 degrees */
+        tpr.ppe = 0x1F0803;
+        /* spe
+         *      10 - full stopped when over 96 degrees
+         *      08 - dynamic throttling starts if over 80 degrees
+         *      03 - dynamic throttling ceases if below 70 degrees
+         */
+        tpr.spe = 0x100803;
+
+        /* STR defaults */
+        /* str1
+         *      10 - stop 16 of 32 cycles
+         */
+        str1.val = 0x1010101010101010ull;
+        /* str2
+         *      10 - stop 16 of 32 cycles
+         */
+        str2 = 0x10;
+
+        /* CR defaults */
+        /* cr1
+         *      4 - normal operation
+         */
+        cr1.val = 0x0404040404040404ull;
+        /* cr2
+         *      4 - normal operation
+         */
+        cr2 = 0x04;
+
+        for_each_possible_cpu (cpu) {
+                pr_debug("processing cpu %d\n", cpu);
+                sysdev = get_cpu_sysdev(cpu);
+                pmd_regs = cbe_get_cpu_pmd_regs(sysdev->id);
+
+                out_be64(&pmd_regs->tm_str2, str2);
+                out_be64(&pmd_regs->tm_str1.val, str1.val);
+                out_be64(&pmd_regs->tm_tpr.val, tpr.val);
+                out_be64(&pmd_regs->tm_cr1.val, cr1.val);
+                out_be64(&pmd_regs->tm_cr2, cr2);
+        }
+}
+
+
+static int __init thermal_init(void)
+{
+        init_default_values();
+
+        spu_add_sysdev_attr_group(&spu_attribute_group);
+        cpu_add_sysdev_attr_group(&ppe_attribute_group);
+
+        return 0;
+}
+module_init(thermal_init);
+
+static void __exit thermal_exit(void)
+{
+        spu_remove_sysdev_attr_group(&spu_attribute_group);
+        cpu_remove_sysdev_attr_group(&ppe_attribute_group);
+}
+module_exit(thermal_exit);
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Christian Krafft <krafft@de.ibm.com>");
+
diff --git a/arch/powerpc/platforms/cell/interrupt.c b/arch/powerpc/platforms/cell/interrupt.c
index a914c12b4060..6666d037eb44 100644
--- a/arch/powerpc/platforms/cell/interrupt.c
+++ b/arch/powerpc/platforms/cell/interrupt.c
@@ -396,3 +396,19 @@ void __init iic_init_IRQ(void)
         /* Enable on current CPU */
         iic_setup_cpu();
 }
+
+void iic_set_interrupt_routing(int cpu, int thread, int priority)
+{
+        struct cbe_iic_regs __iomem *iic_regs = cbe_get_cpu_iic_regs(cpu);
+        u64 iic_ir = 0;
+        int node = cpu >> 1;
+
+        /* Set which node and thread will handle the next interrupt */
+        iic_ir |= CBE_IIC_IR_PRIO(priority) |
+                  CBE_IIC_IR_DEST_NODE(node);
+        if (thread == 0)
+                iic_ir |= CBE_IIC_IR_DEST_UNIT(CBE_IIC_IR_PT_0);
+        else
+                iic_ir |= CBE_IIC_IR_DEST_UNIT(CBE_IIC_IR_PT_1);
+        out_be64(&iic_regs->iic_ir, iic_ir);
+}
diff --git a/arch/powerpc/platforms/cell/interrupt.h b/arch/powerpc/platforms/cell/interrupt.h
index 9ba1d3c17b4b..942dc39d6045 100644
--- a/arch/powerpc/platforms/cell/interrupt.h
+++ b/arch/powerpc/platforms/cell/interrupt.h
@@ -83,5 +83,7 @@ extern u8 iic_get_target_id(int cpu);
 
 extern void spider_init_IRQ(void);
 
+extern void iic_set_interrupt_routing(int cpu, int thread, int priority);
+
 #endif
 #endif /* ASM_CELL_PIC_H */
diff --git a/arch/powerpc/platforms/cell/io-workarounds.c b/arch/powerpc/platforms/cell/io-workarounds.c
new file mode 100644
index 000000000000..7c73128305ec
--- /dev/null
+++ b/arch/powerpc/platforms/cell/io-workarounds.c
@@ -0,0 +1,346 @@
+/*
+ *  Copyright (C) 2006 Benjamin Herrenschmidt <benh@kernel.crashing.org>
+ *                     IBM, Corp.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+#undef DEBUG
+
+#include <linux/kernel.h>
+#include <linux/mm.h>
+#include <linux/pci.h>
+#include <asm/io.h>
+#include <asm/machdep.h>
+#include <asm/pci-bridge.h>
+#include <asm/ppc-pci.h>
+
+
+#define SPIDER_PCI_REG_BASE             0xd000
+#define SPIDER_PCI_VCI_CNTL_STAT        0x0110
+#define SPIDER_PCI_DUMMY_READ           0x0810
+#define SPIDER_PCI_DUMMY_READ_BASE      0x0814
+
+/* Undefine that to re-enable bogus prefetch
+ *
+ * Without that workaround, the chip will do bogus prefetch past
+ * page boundary from system memory. This setting will disable that,
+ * though the documentation is unclear as to the consequences of doing
+ * so, either purely performances, or possible misbehaviour... It's not
+ * clear wether the chip can handle unaligned accesses at all without
+ * prefetching enabled.
+ *
+ * For now, things appear to be behaving properly with that prefetching
+ * disabled and IDE, possibly because IDE isn't doing any unaligned
+ * access.
+ */
+#define SPIDER_DISABLE_PREFETCH
+
+#define MAX_SPIDERS     3
+
+static struct spider_pci_bus {
+        void __iomem    *regs;
+        unsigned long   mmio_start;
+        unsigned long   mmio_end;
+        unsigned long   pio_vstart;
+        unsigned long   pio_vend;
+} spider_pci_busses[MAX_SPIDERS];
+static int spider_pci_count;
+
+static struct spider_pci_bus *spider_pci_find(unsigned long vaddr,
+                                              unsigned long paddr)
+{
+        int i;
+
+        for (i = 0; i < spider_pci_count; i++) {
+                struct spider_pci_bus *bus = &spider_pci_busses[i];
+                if (paddr && paddr >= bus->mmio_start && paddr < bus->mmio_end)
+                        return bus;
+                if (vaddr && vaddr >= bus->pio_vstart && vaddr < bus->pio_vend)
+                        return bus;
+        }
+        return NULL;
+}
+
+static void spider_io_flush(const volatile void __iomem *addr)
+{
+        struct spider_pci_bus *bus;
+        int token;
+
+        /* Get platform token (set by ioremap) from address */
+        token = PCI_GET_ADDR_TOKEN(addr);
+
+        /* Fast path if we have a non-0 token, it indicates which bus we
+         * are on.
+         *
+         * If the token is 0, that means either the the ioremap was done
+         * before we initialized this layer, or it's a PIO operation. We
+         * fallback to a low path in this case. Hopefully, internal devices
+         * which are ioremap'ed early should use in_XX/out_XX functions
+         * instead of the PCI ones and thus not suffer from the slowdown.
+         *
+         * Also note that currently, the workaround will not work for areas
+         * that are not mapped with PTEs (bolted in the hash table). This
+         * is the case for ioremaps done very early at boot (before
+         * mem_init_done) and includes the mapping of the ISA IO space.
+         *
+         * Fortunately, none of the affected devices is expected to do DMA
+         * and thus there should be no problem in practice.
+         *
+         * In order to improve performances, we only do the PTE search for
+         * addresses falling in the PHB IO space area. That means it will
+         * not work for hotplug'ed PHBs but those don't exist with Spider.
+         */
+        if (token && token <= spider_pci_count)
+                bus = &spider_pci_busses[token - 1];
+        else {
+                unsigned long vaddr, paddr;
+                pte_t *ptep;
+
+                /* Fixup physical address */
+                vaddr = (unsigned long)PCI_FIX_ADDR(addr);
+
+                /* Check if it's in allowed range for  PIO */
+                if (vaddr < PHBS_IO_BASE || vaddr >= IMALLOC_BASE)
+                        return;
+
+                /* Try to find a PTE. If not, clear the paddr, we'll do
+                 * a vaddr only lookup (PIO only)
+                 */
+                ptep = find_linux_pte(init_mm.pgd, vaddr);
+                if (ptep == NULL)
+                        paddr = 0;
+                else
+                        paddr = pte_pfn(*ptep) << PAGE_SHIFT;
+
+                bus = spider_pci_find(vaddr, paddr);
+                if (bus == NULL)
+                        return;
+        }
+
+        /* Now do the workaround
+         */
+        (void)in_be32(bus->regs + SPIDER_PCI_DUMMY_READ);
+}
+
+static u8 spider_readb(const volatile void __iomem *addr)
+{
+        u8 val = __do_readb(addr);
+        spider_io_flush(addr);
+        return val;
+}
+
+static u16 spider_readw(const volatile void __iomem *addr)
+{
+        u16 val = __do_readw(addr);
+        spider_io_flush(addr);
+        return val;
+}
+
+static u32 spider_readl(const volatile void __iomem *addr)
+{
+        u32 val = __do_readl(addr);
+        spider_io_flush(addr);
+        return val;
+}
+
+static u64 spider_readq(const volatile void __iomem *addr)
+{
+        u64 val = __do_readq(addr);
+        spider_io_flush(addr);
+        return val;
+}
+
+static u16 spider_readw_be(const volatile void __iomem *addr)
+{
+        u16 val = __do_readw_be(addr);
+        spider_io_flush(addr);
+        return val;
+}
+
+static u32 spider_readl_be(const volatile void __iomem *addr)
+{
+        u32 val = __do_readl_be(addr);
+        spider_io_flush(addr);
+        return val;
+}
+
+static u64 spider_readq_be(const volatile void __iomem *addr)
+{
+        u64 val = __do_readq_be(addr);
+        spider_io_flush(addr);
+        return val;
+}
+
+static void spider_readsb(const volatile void __iomem *addr, void *buf,
+                          unsigned long count)
+{
+        __do_readsb(addr, buf, count);
+        spider_io_flush(addr);
+}
+
+static void spider_readsw(const volatile void __iomem *addr, void *buf,
+                          unsigned long count)
+{
+        __do_readsw(addr, buf, count);
+        spider_io_flush(addr);
+}
+
+static void spider_readsl(const volatile void __iomem *addr, void *buf,
+                          unsigned long count)
+{
+        __do_readsl(addr, buf, count);
+        spider_io_flush(addr);
+}
+
+static void spider_memcpy_fromio(void *dest, const volatile void __iomem *src,
+                                 unsigned long n)
+{
+        __do_memcpy_fromio(dest, src, n);
+        spider_io_flush(src);
+}
+
+
+static void __iomem * spider_ioremap(unsigned long addr, unsigned long size,
+                                     unsigned long flags)
+{
+        struct spider_pci_bus *bus;
+        void __iomem *res = __ioremap(addr, size, flags);
+        int busno;
+
+        pr_debug("spider_ioremap(0x%lx, 0x%lx, 0x%lx) -> 0x%p\n",
+                 addr, size, flags, res);
+
+        bus = spider_pci_find(0, addr);
+        if (bus != NULL) {
+                busno = bus - spider_pci_busses;
+                pr_debug(" found bus %d, setting token\n", busno);
+                PCI_SET_ADDR_TOKEN(res, busno + 1);
+        }
+        pr_debug(" result=0x%p\n", res);
+
+        return res;
+}
+
+static void __init spider_pci_setup_chip(struct spider_pci_bus *bus)
+{
+#ifdef SPIDER_DISABLE_PREFETCH
+        u32 val = in_be32(bus->regs + SPIDER_PCI_VCI_CNTL_STAT);
+        pr_debug(" PVCI_Control_Status was 0x%08x\n", val);
+        out_be32(bus->regs + SPIDER_PCI_VCI_CNTL_STAT, val | 0x8);
+#endif
+
+        /* Configure the dummy address for the workaround */
+        out_be32(bus->regs + SPIDER_PCI_DUMMY_READ_BASE, 0x80000000);
+}
+
+static void __init spider_pci_add_one(struct pci_controller *phb)
+{
+        struct spider_pci_bus *bus = &spider_pci_busses[spider_pci_count];
+        struct device_node *np = phb->arch_data;
+        struct resource rsrc;
+        void __iomem *regs;
+
+        if (spider_pci_count >= MAX_SPIDERS) {
+                printk(KERN_ERR "Too many spider bridges, workarounds"
+                       " disabled for %s\n", np->full_name);
+                return;
+        }
+
+        /* Get the registers for the beast */
+        if (of_address_to_resource(np, 0, &rsrc)) {
+                printk(KERN_ERR "Failed to get registers for spider %s"
+                       " workarounds disabled\n", np->full_name);
+                return;
+        }
+
+        /* Mask out some useless bits in there to get to the base of the
+         * spider chip
+         */
+        rsrc.start &= ~0xfffffffful;
+
+        /* Map them */
+        regs = ioremap(rsrc.start + SPIDER_PCI_REG_BASE, 0x1000);
+        if (regs == NULL) {
+                printk(KERN_ERR "Failed to map registers for spider %s"
+                       " workarounds disabled\n", np->full_name);
+                return;
+        }
+
+        spider_pci_count++;
+
+        /* We assume spiders only have one MMIO resource */
+        bus->mmio_start = phb->mem_resources[0].start;
+        bus->mmio_end = phb->mem_resources[0].end + 1;
+
+        bus->pio_vstart = (unsigned long)phb->io_base_virt;
+        bus->pio_vend = bus->pio_vstart + phb->pci_io_size;
+
+        bus->regs = regs;
+
+        printk(KERN_INFO "PCI: Spider MMIO workaround for %s\n",np->full_name);
+
+        pr_debug(" mmio (P) = 0x%016lx..0x%016lx\n",
+                 bus->mmio_start, bus->mmio_end);
+        pr_debug("  pio (V) = 0x%016lx..0x%016lx\n",
+                 bus->pio_vstart, bus->pio_vend);
+        pr_debug(" regs (P) = 0x%016lx (V) = 0x%p\n",
+                 rsrc.start + SPIDER_PCI_REG_BASE, bus->regs);
+
+        spider_pci_setup_chip(bus);
+}
+
+static struct ppc_pci_io __initdata spider_pci_io = {
+        .readb = spider_readb,
+        .readw = spider_readw,
+        .readl = spider_readl,
+        .readq = spider_readq,
+        .readw_be = spider_readw_be,
+        .readl_be = spider_readl_be,
+        .readq_be = spider_readq_be,
+        .readsb = spider_readsb,
+        .readsw = spider_readsw,
+        .readsl = spider_readsl,
+        .memcpy_fromio = spider_memcpy_fromio,
+};
+
+static int __init spider_pci_workaround_init(void)
+{
+        struct pci_controller *phb;
+
+        if (!machine_is(cell))
+                return 0;
+
+        /* Find spider bridges. We assume they have been all probed
+         * in setup_arch(). If that was to change, we would need to
+         * update this code to cope with dynamically added busses
+         */
+        list_for_each_entry(phb, &hose_list, list_node) {
+                struct device_node *np = phb->arch_data;
+                const char *model = get_property(np, "model", NULL);
+
+                /* If no model property or name isn't exactly "pci", skip */
+                if (model == NULL || strcmp(np->name, "pci"))
+                        continue;
+                /* If model is not "Spider", skip */
+                if (strcmp(model, "Spider"))
+                        continue;
+                spider_pci_add_one(phb);
+        }
+
+        /* No Spider PCI found, exit */
+        if (spider_pci_count == 0)
+                return 0;
+
+        /* Setup IO callbacks. We only setup MMIO reads. PIO reads will
+         * fallback to MMIO reads (though without a token, thus slower)
+         */
+        ppc_pci_io = spider_pci_io;
+
+        /* Setup ioremap callback */
+        ppc_md.ioremap = spider_ioremap;
+
+        return 0;
+}
+arch_initcall(spider_pci_workaround_init);
diff --git a/arch/powerpc/platforms/cell/iommu.c b/arch/powerpc/platforms/cell/iommu.c
index aca4c3db0dde..b43466ba8096 100644
--- a/arch/powerpc/platforms/cell/iommu.c
+++ b/arch/powerpc/platforms/cell/iommu.c
@@ -1,514 +1,747 @@
 /*
  * IOMMU implementation for Cell Broadband Processor Architecture
- * We just establish a linear mapping at boot by setting all the
- * IOPT cache entries in the CPU.
- * The mapping functions should be identical to pci_direct_iommu, 
- * except for the handling of the high order bit that is required
- * by the Spider bridge. These should be split into a separate
- * file at the point where we get a different bridge chip.
  *
- * Copyright (C) 2005 IBM Deutschland Entwicklung GmbH,
- *                       Arnd Bergmann <arndb@de.ibm.com>
+ * (C) Copyright IBM Corporation 2006
  *
- * Based on linear mapping
- * Copyright (C) 2003 Benjamin Herrenschmidt (benh@kernel.crashing.org)
+ * Author: Jeremy Kerr <jk@ozlabs.org>
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version
- * 2 of the License, or (at your option) any later version.
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
 #undef DEBUG
 
 #include <linux/kernel.h>
-#include <linux/pci.h>
-#include <linux/delay.h>
-#include <linux/string.h>
 #include <linux/init.h>
-#include <linux/bootmem.h>
-#include <linux/mm.h>
-#include <linux/dma-mapping.h>
-#include <linux/kernel.h>
-#include <linux/compiler.h>
+#include <linux/interrupt.h>
+#include <linux/notifier.h>
 
-#include <asm/sections.h>
-#include <asm/iommu.h>
-#include <asm/io.h>
 #include <asm/prom.h>
-#include <asm/pci-bridge.h>
+#include <asm/iommu.h>
 #include <asm/machdep.h>
-#include <asm/pmac_feature.h>
-#include <asm/abs_addr.h>
-#include <asm/system.h>
-#include <asm/ppc-pci.h>
+#include <asm/pci-bridge.h>
 #include <asm/udbg.h>
+#include <asm/of_platform.h>
+#include <asm/lmb.h>
 
-#include "iommu.h"
+#include "cbe_regs.h"
+#include "interrupt.h"
 
-static inline unsigned long 
-get_iopt_entry(unsigned long real_address, unsigned long ioid,
-                         unsigned long prot)
-{
-        return (prot & IOPT_PROT_MASK)
-             | (IOPT_COHERENT)
-             | (IOPT_ORDER_VC)
-             | (real_address & IOPT_RPN_MASK)
-             | (ioid & IOPT_IOID_MASK);
-}
+/* Define CELL_IOMMU_REAL_UNMAP to actually unmap non-used pages
+ * instead of leaving them mapped to some dummy page. This can be
+ * enabled once the appropriate workarounds for spider bugs have
+ * been enabled
+ */
+#define CELL_IOMMU_REAL_UNMAP
 
-typedef struct {
-        unsigned long val;
-} ioste;
+/* Define CELL_IOMMU_STRICT_PROTECTION to enforce protection of
+ * IO PTEs based on the transfer direction. That can be enabled
+ * once spider-net has been fixed to pass the correct direction
+ * to the DMA mapping functions
+ */
+#define CELL_IOMMU_STRICT_PROTECTION
+
+
+#define NR_IOMMUS                       2
+
+/* IOC mmap registers */
+#define IOC_Reg_Size                    0x2000
+
+#define IOC_IOPT_CacheInvd              0x908
+#define IOC_IOPT_CacheInvd_NE_Mask      0xffe0000000000000ul
+#define IOC_IOPT_CacheInvd_IOPTE_Mask   0x000003fffffffff8ul
+#define IOC_IOPT_CacheInvd_Busy         0x0000000000000001ul
+
+#define IOC_IOST_Origin                 0x918
+#define IOC_IOST_Origin_E               0x8000000000000000ul
+#define IOC_IOST_Origin_HW              0x0000000000000800ul
+#define IOC_IOST_Origin_HL              0x0000000000000400ul
+
+#define IOC_IO_ExcpStat                 0x920
+#define IOC_IO_ExcpStat_V               0x8000000000000000ul
+#define IOC_IO_ExcpStat_SPF_Mask        0x6000000000000000ul
+#define IOC_IO_ExcpStat_SPF_S           0x6000000000000000ul
+#define IOC_IO_ExcpStat_SPF_P           0x4000000000000000ul
+#define IOC_IO_ExcpStat_ADDR_Mask       0x00000007fffff000ul
+#define IOC_IO_ExcpStat_RW_Mask         0x0000000000000800ul
+#define IOC_IO_ExcpStat_IOID_Mask       0x00000000000007fful
+
+#define IOC_IO_ExcpMask                 0x928
+#define IOC_IO_ExcpMask_SFE             0x4000000000000000ul
+#define IOC_IO_ExcpMask_PFE             0x2000000000000000ul
+
+#define IOC_IOCmd_Offset                0x1000
+
+#define IOC_IOCmd_Cfg                   0xc00
+#define IOC_IOCmd_Cfg_TE                0x0000800000000000ul
+
+
+/* Segment table entries */
+#define IOSTE_V                 0x8000000000000000ul /* valid */
+#define IOSTE_H                 0x4000000000000000ul /* cache hint */
+#define IOSTE_PT_Base_RPN_Mask  0x3ffffffffffff000ul /* base RPN of IOPT */
+#define IOSTE_NPPT_Mask         0x0000000000000fe0ul /* no. pages in IOPT */
+#define IOSTE_PS_Mask           0x0000000000000007ul /* page size */
+#define IOSTE_PS_4K             0x0000000000000001ul /*   - 4kB  */
+#define IOSTE_PS_64K            0x0000000000000003ul /*   - 64kB */
+#define IOSTE_PS_1M             0x0000000000000005ul /*   - 1MB  */
+#define IOSTE_PS_16M            0x0000000000000007ul /*   - 16MB */
+
+/* Page table entries */
+#define IOPTE_PP_W              0x8000000000000000ul /* protection: write */
+#define IOPTE_PP_R              0x4000000000000000ul /* protection: read */
+#define IOPTE_M                 0x2000000000000000ul /* coherency required */
+#define IOPTE_SO_R              0x1000000000000000ul /* ordering: writes */
+#define IOPTE_SO_RW             0x1800000000000000ul /* ordering: r & w */
+#define IOPTE_RPN_Mask          0x07fffffffffff000ul /* RPN */
+#define IOPTE_H                 0x0000000000000800ul /* cache hint */
+#define IOPTE_IOID_Mask         0x00000000000007fful /* ioid */
+
+
+/* IOMMU sizing */
+#define IO_SEGMENT_SHIFT        28
+#define IO_PAGENO_BITS          (IO_SEGMENT_SHIFT - IOMMU_PAGE_SHIFT)
+
+/* The high bit needs to be set on every DMA address */
+#define SPIDER_DMA_OFFSET       0x80000000ul
+
+struct iommu_window {
+        struct list_head list;
+        struct cbe_iommu *iommu;
+        unsigned long offset;
+        unsigned long size;
+        unsigned long pte_offset;
+        unsigned int ioid;
+        struct iommu_table table;
+};
 
-static inline ioste
-mk_ioste(unsigned long val)
-{
-        ioste ioste = { .val = val, };
-        return ioste;
-}
+#define NAMESIZE 8
+struct cbe_iommu {
+        int nid;
+        char name[NAMESIZE];
+        void __iomem *xlate_regs;
+        void __iomem *cmd_regs;
+        unsigned long *stab;
+        unsigned long *ptab;
+        void *pad_page;
+        struct list_head windows;
+};
+
+/* Static array of iommus, one per node
+ *   each contains a list of windows, keyed from dma_window property
+ *   - on bus setup, look for a matching window, or create one
+ *   - on dev setup, assign iommu_table ptr
+ */
+static struct cbe_iommu iommus[NR_IOMMUS];
+static int cbe_nr_iommus;
 
-static inline ioste
-get_iost_entry(unsigned long iopt_base, unsigned long io_address, unsigned page_size)
+static void invalidate_tce_cache(struct cbe_iommu *iommu, unsigned long *pte,
+                long n_ptes)
 {
-        unsigned long ps;
-        unsigned long iostep;
-        unsigned long nnpt;
-        unsigned long shift;
-
-        switch (page_size) {
-        case 0x1000000:
-                ps = IOST_PS_16M;
-                nnpt = 0;  /* one page per segment */
-                shift = 5; /* segment has 16 iopt entries */
-                break;
-
-        case 0x100000:
-                ps = IOST_PS_1M;
-                nnpt = 0;  /* one page per segment */
-                shift = 1; /* segment has 256 iopt entries */
-                break;
-
-        case 0x10000:
-                ps = IOST_PS_64K;
-                nnpt = 0x07; /* 8 pages per io page table */
-                shift = 0;   /* all entries are used */
-                break;
-
-        case 0x1000:
-                ps = IOST_PS_4K;
-                nnpt = 0x7f; /* 128 pages per io page table */
-                shift = 0;   /* all entries are used */
-                break;
-
-        default: /* not a known compile time constant */
-                {
-                        /* BUILD_BUG_ON() is not usable here */
-                        extern void __get_iost_entry_bad_page_size(void);
-                        __get_iost_entry_bad_page_size();
-                }
-                break;
-        }
+        unsigned long *reg, val;
+        long n;
 
-        iostep = iopt_base +
-                         /* need 8 bytes per iopte */
-                        (((io_address / page_size * 8)
-                         /* align io page tables on 4k page boundaries */
-                                 << shift) 
-                         /* nnpt+1 pages go into each iopt */
-                                 & ~(nnpt << 12));
-
-        nnpt++; /* this seems to work, but the documentation is not clear
-                   about wether we put nnpt or nnpt-1 into the ioste bits.
-                   In theory, this can't work for 4k pages. */
-        return mk_ioste(IOST_VALID_MASK
-                        | (iostep & IOST_PT_BASE_MASK)
-                        | ((nnpt << 5) & IOST_NNPT_MASK)
-                        | (ps & IOST_PS_MASK));
-}
+        reg = iommu->xlate_regs + IOC_IOPT_CacheInvd;
 
-/* compute the address of an io pte */
-static inline unsigned long
-get_ioptep(ioste iost_entry, unsigned long io_address)
-{
-        unsigned long iopt_base;
-        unsigned long page_size;
-        unsigned long page_number;
-        unsigned long iopt_offset;
-
-        iopt_base = iost_entry.val & IOST_PT_BASE_MASK;
-        page_size = iost_entry.val & IOST_PS_MASK;
-
-        /* decode page size to compute page number */
-        page_number = (io_address & 0x0fffffff) >> (10 + 2 * page_size);
-        /* page number is an offset into the io page table */
-        iopt_offset = (page_number << 3) & 0x7fff8ul;
-        return iopt_base + iopt_offset;
-}
+        while (n_ptes > 0) {
+                /* we can invalidate up to 1 << 11 PTEs at once */
+                n = min(n_ptes, 1l << 11);
+                val = (((n /*- 1*/) << 53) & IOC_IOPT_CacheInvd_NE_Mask)
+                        | (__pa(pte) & IOC_IOPT_CacheInvd_IOPTE_Mask)
+                        | IOC_IOPT_CacheInvd_Busy;
 
-/* compute the tag field of the iopt cache entry */
-static inline unsigned long
-get_ioc_tag(ioste iost_entry, unsigned long io_address)
-{
-        unsigned long iopte = get_ioptep(iost_entry, io_address);
+                out_be64(reg, val);
+                while (in_be64(reg) & IOC_IOPT_CacheInvd_Busy)
+                        ;
 
-        return IOPT_VALID_MASK
-             | ((iopte & 0x00000000000000ff8ul) >> 3)
-             | ((iopte & 0x0000003fffffc0000ul) >> 9);
+                n_ptes -= n;
+                pte += n;
+        }
 }
 
-/* compute the hashed 6 bit index for the 4-way associative pte cache */
-static inline unsigned long
-get_ioc_hash(ioste iost_entry, unsigned long io_address)
+static void tce_build_cell(struct iommu_table *tbl, long index, long npages,
+                unsigned long uaddr, enum dma_data_direction direction)
 {
-        unsigned long iopte = get_ioptep(iost_entry, io_address);
-
-        return ((iopte & 0x000000000000001f8ul) >> 3)
-             ^ ((iopte & 0x00000000000020000ul) >> 17)
-             ^ ((iopte & 0x00000000000010000ul) >> 15)
-             ^ ((iopte & 0x00000000000008000ul) >> 13)
-             ^ ((iopte & 0x00000000000004000ul) >> 11)
-             ^ ((iopte & 0x00000000000002000ul) >> 9)
-             ^ ((iopte & 0x00000000000001000ul) >> 7);
+        int i;
+        unsigned long *io_pte, base_pte;
+        struct iommu_window *window =
+                container_of(tbl, struct iommu_window, table);
+
+        /* implementing proper protection causes problems with the spidernet
+         * driver - check mapping directions later, but allow read & write by
+         * default for now.*/
+#ifdef CELL_IOMMU_STRICT_PROTECTION
+        /* to avoid referencing a global, we use a trick here to setup the
+         * protection bit. "prot" is setup to be 3 fields of 4 bits apprended
+         * together for each of the 3 supported direction values. It is then
+         * shifted left so that the fields matching the desired direction
+         * lands on the appropriate bits, and other bits are masked out.
+         */
+        const unsigned long prot = 0xc48;
+        base_pte =
+                ((prot << (52 + 4 * direction)) & (IOPTE_PP_W | IOPTE_PP_R))
+                | IOPTE_M | IOPTE_SO_RW | (window->ioid & IOPTE_IOID_Mask);
+#else
+        base_pte = IOPTE_PP_W | IOPTE_PP_R | IOPTE_M | IOPTE_SO_RW |
+                (window->ioid & IOPTE_IOID_Mask);
+#endif
+
+        io_pte = (unsigned long *)tbl->it_base + (index - window->pte_offset);
+
+        for (i = 0; i < npages; i++, uaddr += IOMMU_PAGE_SIZE)
+                io_pte[i] = base_pte | (__pa(uaddr) & IOPTE_RPN_Mask);
+
+        mb();
+
+        invalidate_tce_cache(window->iommu, io_pte, npages);
+
+        pr_debug("tce_build_cell(index=%lx,n=%lx,dir=%d,base_pte=%lx)\n",
+                 index, npages, direction, base_pte);
 }
 
-/* same as above, but pretend that we have a simpler 1-way associative
-   pte cache with an 8 bit index */
-static inline unsigned long
-get_ioc_hash_1way(ioste iost_entry, unsigned long io_address)
+static void tce_free_cell(struct iommu_table *tbl, long index, long npages)
 {
-        unsigned long iopte = get_ioptep(iost_entry, io_address);
-
-        return ((iopte & 0x000000000000001f8ul) >> 3)
-             ^ ((iopte & 0x00000000000020000ul) >> 17)
-             ^ ((iopte & 0x00000000000010000ul) >> 15)
-             ^ ((iopte & 0x00000000000008000ul) >> 13)
-             ^ ((iopte & 0x00000000000004000ul) >> 11)
-             ^ ((iopte & 0x00000000000002000ul) >> 9)
-             ^ ((iopte & 0x00000000000001000ul) >> 7)
-             ^ ((iopte & 0x0000000000000c000ul) >> 8);
-}
 
-static inline ioste
-get_iost_cache(void __iomem *base, unsigned long index)
-{
-        unsigned long __iomem *p = (base + IOC_ST_CACHE_DIR);
-        return mk_ioste(in_be64(&p[index]));
-}
+        int i;
+        unsigned long *io_pte, pte;
+        struct iommu_window *window =
+                container_of(tbl, struct iommu_window, table);
 
-static inline void
-set_iost_cache(void __iomem *base, unsigned long index, ioste ste)
-{
-        unsigned long __iomem *p = (base + IOC_ST_CACHE_DIR);
-        pr_debug("ioste %02lx was %016lx, store %016lx", index,
-                        get_iost_cache(base, index).val, ste.val);
-        out_be64(&p[index], ste.val);
-        pr_debug(" now %016lx\n", get_iost_cache(base, index).val);
-}
+        pr_debug("tce_free_cell(index=%lx,n=%lx)\n", index, npages);
 
-static inline unsigned long
-get_iopt_cache(void __iomem *base, unsigned long index, unsigned long *tag)
-{
-        unsigned long __iomem *tags = (void *)(base + IOC_PT_CACHE_DIR);
-        unsigned long __iomem *p = (void *)(base + IOC_PT_CACHE_REG);   
+#ifdef CELL_IOMMU_REAL_UNMAP
+        pte = 0;
+#else
+        /* spider bridge does PCI reads after freeing - insert a mapping
+         * to a scratch page instead of an invalid entry */
+        pte = IOPTE_PP_R | IOPTE_M | IOPTE_SO_RW | __pa(window->iommu->pad_page)
+                | (window->ioid & IOPTE_IOID_Mask);
+#endif
 
-        *tag = tags[index];
-        rmb();
-        return *p;
-}
+        io_pte = (unsigned long *)tbl->it_base + (index - window->pte_offset);
 
-static inline void
-set_iopt_cache(void __iomem *base, unsigned long index,
-                 unsigned long tag, unsigned long val)
-{
-        unsigned long __iomem *tags = base + IOC_PT_CACHE_DIR;
-        unsigned long __iomem *p = base + IOC_PT_CACHE_REG;
+        for (i = 0; i < npages; i++)
+                io_pte[i] = pte;
+
+        mb();
 
-        out_be64(p, val);
-        out_be64(&tags[index], tag);
+        invalidate_tce_cache(window->iommu, io_pte, npages);
 }
 
-static inline void
-set_iost_origin(void __iomem *base)
+static irqreturn_t ioc_interrupt(int irq, void *data)
 {
-        unsigned long __iomem *p = base + IOC_ST_ORIGIN;
-        unsigned long origin = IOSTO_ENABLE | IOSTO_SW;
-
-        pr_debug("iost_origin %016lx, now %016lx\n", in_be64(p), origin);
-        out_be64(p, origin);
+        unsigned long stat;
+        struct cbe_iommu *iommu = data;
+
+        stat = in_be64(iommu->xlate_regs + IOC_IO_ExcpStat);
+
+        /* Might want to rate limit it */
+        printk(KERN_ERR "iommu: DMA exception 0x%016lx\n", stat);
+        printk(KERN_ERR "  V=%d, SPF=[%c%c], RW=%s, IOID=0x%04x\n",
+               !!(stat & IOC_IO_ExcpStat_V),
+               (stat & IOC_IO_ExcpStat_SPF_S) ? 'S' : ' ',
+               (stat & IOC_IO_ExcpStat_SPF_P) ? 'P' : ' ',
+               (stat & IOC_IO_ExcpStat_RW_Mask) ? "Read" : "Write",
+               (unsigned int)(stat & IOC_IO_ExcpStat_IOID_Mask));
+        printk(KERN_ERR "  page=0x%016lx\n",
+               stat & IOC_IO_ExcpStat_ADDR_Mask);
+
+        /* clear interrupt */
+        stat &= ~IOC_IO_ExcpStat_V;
+        out_be64(iommu->xlate_regs + IOC_IO_ExcpStat, stat);
+
+        return IRQ_HANDLED;
 }
 
-static inline void
-set_iocmd_config(void __iomem *base)
+static int cell_iommu_find_ioc(int nid, unsigned long *base)
 {
-        unsigned long __iomem *p = base + 0xc00;
-        unsigned long conf;
+        struct device_node *np;
+        struct resource r;
+
+        *base = 0;
+
+        /* First look for new style /be nodes */
+        for_each_node_by_name(np, "ioc") {
+                if (of_node_to_nid(np) != nid)
+                        continue;
+                if (of_address_to_resource(np, 0, &r)) {
+                        printk(KERN_ERR "iommu: can't get address for %s\n",
+                               np->full_name);
+                        continue;
+                }
+                *base = r.start;
+                of_node_put(np);
+                return 0;
+        }
 
-        conf = in_be64(p);
-        pr_debug("iost_conf %016lx, now %016lx\n", conf, conf | IOCMD_CONF_TE);
-        out_be64(p, conf | IOCMD_CONF_TE);
+        /* Ok, let's try the old way */
+        for_each_node_by_type(np, "cpu") {
+                const unsigned int *nidp;
+                const unsigned long *tmp;
+
+                nidp = get_property(np, "node-id", NULL);
+                if (nidp && *nidp == nid) {
+                        tmp = get_property(np, "ioc-translation", NULL);
+                        if (tmp) {
+                                *base = *tmp;
+                                of_node_put(np);
+                                return 0;
+                        }
+                }
+        }
+
+        return -ENODEV;
 }
 
-static void enable_mapping(void __iomem *base, void __iomem *mmio_base)
+static void cell_iommu_setup_hardware(struct cbe_iommu *iommu, unsigned long size)
 {
-        set_iocmd_config(base);
-        set_iost_origin(mmio_base);
-}
+        struct page *page;
+        int ret, i;
+        unsigned long reg, segments, pages_per_segment, ptab_size, n_pte_pages;
+        unsigned long xlate_base;
+        unsigned int virq;
+
+        if (cell_iommu_find_ioc(iommu->nid, &xlate_base))
+                panic("%s: missing IOC register mappings for node %d\n",
+                      __FUNCTION__, iommu->nid);
+
+        iommu->xlate_regs = ioremap(xlate_base, IOC_Reg_Size);
+        iommu->cmd_regs = iommu->xlate_regs + IOC_IOCmd_Offset;
+
+        segments = size >> IO_SEGMENT_SHIFT;
+        pages_per_segment = 1ull << IO_PAGENO_BITS;
+
+        pr_debug("%s: iommu[%d]: segments: %lu, pages per segment: %lu\n",
+                        __FUNCTION__, iommu->nid, segments, pages_per_segment);
+
+        /* set up the segment table */
+        page = alloc_pages_node(iommu->nid, GFP_KERNEL, 0);
+        BUG_ON(!page);
+        iommu->stab = page_address(page);
+        clear_page(iommu->stab);
+
+        /* ... and the page tables. Since these are contiguous, we can treat
+         * the page tables as one array of ptes, like pSeries does.
+         */
+        ptab_size = segments * pages_per_segment * sizeof(unsigned long);
+        pr_debug("%s: iommu[%d]: ptab_size: %lu, order: %d\n", __FUNCTION__,
+                        iommu->nid, ptab_size, get_order(ptab_size));
+        page = alloc_pages_node(iommu->nid, GFP_KERNEL, get_order(ptab_size));
+        BUG_ON(!page);
+
+        iommu->ptab = page_address(page);
+        memset(iommu->ptab, 0, ptab_size);
+
+        /* allocate a bogus page for the end of each mapping */
+        page = alloc_pages_node(iommu->nid, GFP_KERNEL, 0);
+        BUG_ON(!page);
+        iommu->pad_page = page_address(page);
+        clear_page(iommu->pad_page);
+
+        /* number of pages needed for a page table */
+        n_pte_pages = (pages_per_segment *
+                       sizeof(unsigned long)) >> IOMMU_PAGE_SHIFT;
+
+        pr_debug("%s: iommu[%d]: stab at %p, ptab at %p, n_pte_pages: %lu\n",
+                        __FUNCTION__, iommu->nid, iommu->stab, iommu->ptab,
+                        n_pte_pages);
+
+        /* initialise the STEs */
+        reg = IOSTE_V | ((n_pte_pages - 1) << 5);
+
+        if (IOMMU_PAGE_SIZE == 0x1000)
+                reg |= IOSTE_PS_4K;
+        else if (IOMMU_PAGE_SIZE == 0x10000)
+                reg |= IOSTE_PS_64K;
+        else {
+                extern void __unknown_page_size_error(void);
+                __unknown_page_size_error();
+        }
+
+        pr_debug("Setting up IOMMU stab:\n");
+        for (i = 0; i * (1ul << IO_SEGMENT_SHIFT) < size; i++) {
+                iommu->stab[i] = reg |
+                        (__pa(iommu->ptab) + n_pte_pages * IOMMU_PAGE_SIZE * i);
+                pr_debug("\t[%d] 0x%016lx\n", i, iommu->stab[i]);
+        }
 
-static void iommu_dev_setup_null(struct pci_dev *d) { }
-static void iommu_bus_setup_null(struct pci_bus *b) { }
+        /* ensure that the STEs have updated */
+        mb();
 
-struct cell_iommu {
-        unsigned long base;
-        unsigned long mmio_base;
-        void __iomem *mapped_base;
-        void __iomem *mapped_mmio_base;
-};
+        /* setup interrupts for the iommu. */
+        reg = in_be64(iommu->xlate_regs + IOC_IO_ExcpStat);
+        out_be64(iommu->xlate_regs + IOC_IO_ExcpStat,
+                        reg & ~IOC_IO_ExcpStat_V);
+        out_be64(iommu->xlate_regs + IOC_IO_ExcpMask,
+                        IOC_IO_ExcpMask_PFE | IOC_IO_ExcpMask_SFE);
 
-static struct cell_iommu cell_iommus[NR_CPUS];
+        virq = irq_create_mapping(NULL,
+                        IIC_IRQ_IOEX_ATI | (iommu->nid << IIC_IRQ_NODE_SHIFT));
+        BUG_ON(virq == NO_IRQ);
 
-/* initialize the iommu to support a simple linear mapping
- * for each DMA window used by any device. For now, we
- * happen to know that there is only one DMA window in use,
- * starting at iopt_phys_offset. */
-static void cell_do_map_iommu(struct cell_iommu *iommu,
-                              unsigned int ioid,
-                              unsigned long map_start,
-                              unsigned long map_size)
-{
-        unsigned long io_address, real_address;
-        void __iomem *ioc_base, *ioc_mmio_base;
-        ioste ioste;
-        unsigned long index;
+        ret = request_irq(virq, ioc_interrupt, IRQF_DISABLED,
+                        iommu->name, iommu);
+        BUG_ON(ret);
 
-        /* we pretend the io page table was at a very high address */
-        const unsigned long fake_iopt = 0x10000000000ul;
-        const unsigned long io_page_size = 0x1000000; /* use 16M pages */
-        const unsigned long io_segment_size = 0x10000000; /* 256M */
-
-        ioc_base = iommu->mapped_base;
-        ioc_mmio_base = iommu->mapped_mmio_base;
-
-        for (real_address = 0, io_address = map_start;
-             io_address <= map_start + map_size;
-             real_address += io_page_size, io_address += io_page_size) {
-                ioste = get_iost_entry(fake_iopt, io_address, io_page_size);
-                if ((real_address % io_segment_size) == 0) /* segment start */
-                        set_iost_cache(ioc_mmio_base,
-                                       io_address >> 28, ioste);
-                index = get_ioc_hash_1way(ioste, io_address);
-                pr_debug("addr %08lx, index %02lx, ioste %016lx\n",
-                                         io_address, index, ioste.val);
-                set_iopt_cache(ioc_mmio_base,
-                        get_ioc_hash_1way(ioste, io_address),
-                        get_ioc_tag(ioste, io_address),
-                        get_iopt_entry(real_address, ioid, IOPT_PROT_RW));
-        }
+        /* set the IOC segment table origin register (and turn on the iommu) */
+        reg = IOC_IOST_Origin_E | __pa(iommu->stab) | IOC_IOST_Origin_HW;
+        out_be64(iommu->xlate_regs + IOC_IOST_Origin, reg);
+        in_be64(iommu->xlate_regs + IOC_IOST_Origin);
+
+        /* turn on IO translation */
+        reg = in_be64(iommu->cmd_regs + IOC_IOCmd_Cfg) | IOC_IOCmd_Cfg_TE;
+        out_be64(iommu->cmd_regs + IOC_IOCmd_Cfg, reg);
 }
 
-static void iommu_devnode_setup(struct device_node *d)
+#if 0/* Unused for now */
+static struct iommu_window *find_window(struct cbe_iommu *iommu,
+                unsigned long offset, unsigned long size)
 {
-        const unsigned int *ioid;
-        unsigned long map_start, map_size, token;
-        const unsigned long *dma_window;
-        struct cell_iommu *iommu;
+        struct iommu_window *window;
 
-        ioid = get_property(d, "ioid", NULL);
-        if (!ioid)
-                pr_debug("No ioid entry found !\n");
+        /* todo: check for overlapping (but not equal) windows) */
 
-        dma_window = get_property(d, "ibm,dma-window", NULL);
-        if (!dma_window)
-                pr_debug("No ibm,dma-window entry found !\n");
+        list_for_each_entry(window, &(iommu->windows), list) {
+                if (window->offset == offset && window->size == size)
+                        return window;
+        }
 
-        map_start = dma_window[1];
-        map_size = dma_window[2];
-        token = dma_window[0] >> 32;
+        return NULL;
+}
+#endif
 
-        iommu = &cell_iommus[token];
+static struct iommu_window * __init
+cell_iommu_setup_window(struct cbe_iommu *iommu, struct device_node *np,
+                        unsigned long offset, unsigned long size,
+                        unsigned long pte_offset)
+{
+        struct iommu_window *window;
+        const unsigned int *ioid;
 
-        cell_do_map_iommu(iommu, *ioid, map_start, map_size);
+        ioid = get_property(np, "ioid", NULL);
+        if (ioid == NULL)
+                printk(KERN_WARNING "iommu: missing ioid for %s using 0\n",
+                       np->full_name);
+
+        window = kmalloc_node(sizeof(*window), GFP_KERNEL, iommu->nid);
+        BUG_ON(window == NULL);
+
+        window->offset = offset;
+        window->size = size;
+        window->ioid = ioid ? *ioid : 0;
+        window->iommu = iommu;
+        window->pte_offset = pte_offset;
+
+        window->table.it_blocksize = 16;
+        window->table.it_base = (unsigned long)iommu->ptab;
+        window->table.it_index = iommu->nid;
+        window->table.it_offset = (offset >> IOMMU_PAGE_SHIFT) +
+                window->pte_offset;
+        window->table.it_size = size >> IOMMU_PAGE_SHIFT;
+
+        iommu_init_table(&window->table, iommu->nid);
+
+        pr_debug("\tioid      %d\n", window->ioid);
+        pr_debug("\tblocksize %ld\n", window->table.it_blocksize);
+        pr_debug("\tbase      0x%016lx\n", window->table.it_base);
+        pr_debug("\toffset    0x%lx\n", window->table.it_offset);
+        pr_debug("\tsize      %ld\n", window->table.it_size);
+
+        list_add(&window->list, &iommu->windows);
+
+        if (offset != 0)
+                return window;
+
+        /* We need to map and reserve the first IOMMU page since it's used
+         * by the spider workaround. In theory, we only need to do that when
+         * running on spider but it doesn't really matter.
+         *
+         * This code also assumes that we have a window that starts at 0,
+         * which is the case on all spider based blades.
+         */
+        __set_bit(0, window->table.it_map);
+        tce_build_cell(&window->table, window->table.it_offset, 1,
+                       (unsigned long)iommu->pad_page, DMA_TO_DEVICE);
+        window->table.it_hint = window->table.it_blocksize;
+
+        return window;
 }
 
-static void iommu_bus_setup(struct pci_bus *b)
+static struct cbe_iommu *cell_iommu_for_node(int nid)
 {
-        struct device_node *d = (struct device_node *)b->sysdata;
-        iommu_devnode_setup(d);
-}
+        int i;
 
+        for (i = 0; i < cbe_nr_iommus; i++)
+                if (iommus[i].nid == nid)
+                        return &iommus[i];
+        return NULL;
+}
 
-static int cell_map_iommu_hardcoded(int num_nodes)
+static void cell_dma_dev_setup(struct device *dev)
 {
-        struct cell_iommu *iommu = NULL;
-
-        pr_debug("%s(%d): Using hardcoded defaults\n", __FUNCTION__, __LINE__);
+        struct iommu_window *window;
+        struct cbe_iommu *iommu;
+        struct dev_archdata *archdata = &dev->archdata;
+
+        /* If we run without iommu, no need to do anything */
+        if (pci_dma_ops == &dma_direct_ops)
+                return;
+
+        /* Current implementation uses the first window available in that
+         * node's iommu. We -might- do something smarter later though it may
+         * never be necessary
+         */
+        iommu = cell_iommu_for_node(archdata->numa_node);
+        if (iommu == NULL || list_empty(&iommu->windows)) {
+                printk(KERN_ERR "iommu: missing iommu for %s (node %d)\n",
+                       archdata->of_node ? archdata->of_node->full_name : "?",
+                       archdata->numa_node);
+                return;
+        }
+        window = list_entry(iommu->windows.next, struct iommu_window, list);
 
-        /* node 0 */
-        iommu = &cell_iommus[0];
-        iommu->mapped_base = ioremap(0x20000511000ul, 0x1000);
-        iommu->mapped_mmio_base = ioremap(0x20000510000ul, 0x1000);
+        archdata->dma_data = &window->table;
+}
 
-        enable_mapping(iommu->mapped_base, iommu->mapped_mmio_base);
+static void cell_pci_dma_dev_setup(struct pci_dev *dev)
+{
+        cell_dma_dev_setup(&dev->dev);
+}
 
-        cell_do_map_iommu(iommu, 0x048a,
-                          0x20000000ul,0x20000000ul);
+static int cell_of_bus_notify(struct notifier_block *nb, unsigned long action,
+                              void *data)
+{
+        struct device *dev = data;
 
-        if (num_nodes < 2)
+        /* We are only intereted in device addition */
+        if (action != BUS_NOTIFY_ADD_DEVICE)
                 return 0;
 
-        /* node 1 */
-        iommu = &cell_iommus[1];
-        iommu->mapped_base = ioremap(0x30000511000ul, 0x1000);
-        iommu->mapped_mmio_base = ioremap(0x30000510000ul, 0x1000);
-
-        enable_mapping(iommu->mapped_base, iommu->mapped_mmio_base);
+        /* We use the PCI DMA ops */
+        dev->archdata.dma_ops = pci_dma_ops;
 
-        cell_do_map_iommu(iommu, 0x048a,
-                          0x20000000,0x20000000ul);
+        cell_dma_dev_setup(dev);
 
         return 0;
 }
 
+static struct notifier_block cell_of_bus_notifier = {
+        .notifier_call = cell_of_bus_notify
+};
 
-static int cell_map_iommu(void)
+static int __init cell_iommu_get_window(struct device_node *np,
+                                         unsigned long *base,
+                                         unsigned long *size)
 {
-        unsigned int num_nodes = 0;
-        const unsigned int *node_id;
-        const unsigned long *base, *mmio_base;
-        struct device_node *dn;
-        struct cell_iommu *iommu = NULL;
-
-        /* determine number of nodes (=iommus) */
-        pr_debug("%s(%d): determining number of nodes...", __FUNCTION__, __LINE__);
-        for(dn = of_find_node_by_type(NULL, "cpu");
-            dn;
-            dn = of_find_node_by_type(dn, "cpu")) {
-                node_id = get_property(dn, "node-id", NULL);
-
-                if (num_nodes < *node_id)
-                        num_nodes = *node_id;
-                }
-
-        num_nodes++;
-        pr_debug("%i found.\n", num_nodes);
+        const void *dma_window;
+        unsigned long index;
 
-        /* map the iommu registers for each node */
-        pr_debug("%s(%d): Looping through nodes\n", __FUNCTION__, __LINE__);
-        for(dn = of_find_node_by_type(NULL, "cpu");
-            dn;
-            dn = of_find_node_by_type(dn, "cpu")) {
+        /* Use ibm,dma-window if available, else, hard code ! */
+        dma_window = get_property(np, "ibm,dma-window", NULL);
+        if (dma_window == NULL) {
+                *base = 0;
+                *size = 0x80000000u;
+                return -ENODEV;
+        }
 
-                node_id = get_property(dn, "node-id", NULL);
-                base = get_property(dn, "ioc-cache", NULL);
-                mmio_base = get_property(dn, "ioc-translation", NULL);
+        of_parse_dma_window(np, dma_window, &index, base, size);
+        return 0;
+}
 
-                if (!base || !mmio_base || !node_id)
-                        return cell_map_iommu_hardcoded(num_nodes);
+static void __init cell_iommu_init_one(struct device_node *np, unsigned long offset)
+{
+        struct cbe_iommu *iommu;
+        unsigned long base, size;
+        int nid, i;
+
+        /* Get node ID */
+        nid = of_node_to_nid(np);
+        if (nid < 0) {
+                printk(KERN_ERR "iommu: failed to get node for %s\n",
+                       np->full_name);
+                return;
+        }
+        pr_debug("iommu: setting up iommu for node %d (%s)\n",
+                 nid, np->full_name);
+
+        /* XXX todo: If we can have multiple windows on the same IOMMU, which
+         * isn't the case today, we probably want here to check wether the
+         * iommu for that node is already setup.
+         * However, there might be issue with getting the size right so let's
+         * ignore that for now. We might want to completely get rid of the
+         * multiple window support since the cell iommu supports per-page ioids
+         */
+
+        if (cbe_nr_iommus >= NR_IOMMUS) {
+                printk(KERN_ERR "iommu: too many IOMMUs detected ! (%s)\n",
+                       np->full_name);
+                return;
+        }
 
-                iommu = &cell_iommus[*node_id];
-                iommu->base = *base;
-                iommu->mmio_base = *mmio_base;
+        /* Init base fields */
+        i = cbe_nr_iommus++;
+        iommu = &iommus[i];
+        iommu->stab = 0;
+        iommu->nid = nid;
+        snprintf(iommu->name, sizeof(iommu->name), "iommu%d", i);
+        INIT_LIST_HEAD(&iommu->windows);
 
-                iommu->mapped_base = ioremap(*base, 0x1000);
-                iommu->mapped_mmio_base = ioremap(*mmio_base, 0x1000);
+        /* Obtain a window for it */
+        cell_iommu_get_window(np, &base, &size);
 
-                enable_mapping(iommu->mapped_base,
-                               iommu->mapped_mmio_base);
+        pr_debug("\ttranslating window 0x%lx...0x%lx\n",
+                 base, base + size - 1);
 
-                /* everything else will be done in iommu_bus_setup */
-        }
+        /* Initialize the hardware */
+        cell_iommu_setup_hardware(iommu, size);
 
-        return 1;
+        /* Setup the iommu_table */
+        cell_iommu_setup_window(iommu, np, base, size,
+                                offset >> IOMMU_PAGE_SHIFT);
 }
 
-static void *cell_alloc_coherent(struct device *hwdev, size_t size,
-                           dma_addr_t *dma_handle, gfp_t flag)
+static void __init cell_disable_iommus(void)
 {
-        void *ret;
-
-        ret = (void *)__get_free_pages(flag, get_order(size));
-        if (ret != NULL) {
-                memset(ret, 0, size);
-                *dma_handle = virt_to_abs(ret) | CELL_DMA_VALID;
+        int node;
+        unsigned long base, val;
+        void __iomem *xregs, *cregs;
+
+        /* Make sure IOC translation is disabled on all nodes */
+        for_each_online_node(node) {
+                if (cell_iommu_find_ioc(node, &base))
+                        continue;
+                xregs = ioremap(base, IOC_Reg_Size);
+                if (xregs == NULL)
+                        continue;
+                cregs = xregs + IOC_IOCmd_Offset;
+
+                pr_debug("iommu: cleaning up iommu on node %d\n", node);
+
+                out_be64(xregs + IOC_IOST_Origin, 0);
+                (void)in_be64(xregs + IOC_IOST_Origin);
+                val = in_be64(cregs + IOC_IOCmd_Cfg);
+                val &= ~IOC_IOCmd_Cfg_TE;
+                out_be64(cregs + IOC_IOCmd_Cfg, val);
+                (void)in_be64(cregs + IOC_IOCmd_Cfg);
+
+                iounmap(xregs);
         }
-        return ret;
 }
 
-static void cell_free_coherent(struct device *hwdev, size_t size,
-                                 void *vaddr, dma_addr_t dma_handle)
+static int __init cell_iommu_init_disabled(void)
 {
-        free_pages((unsigned long)vaddr, get_order(size));
-}
+        struct device_node *np = NULL;
+        unsigned long base = 0, size;
+
+        /* When no iommu is present, we use direct DMA ops */
+        pci_dma_ops = &dma_direct_ops;
+
+        /* First make sure all IOC translation is turned off */
+        cell_disable_iommus();
+
+        /* If we have no Axon, we set up the spider DMA magic offset */
+        if (of_find_node_by_name(NULL, "axon") == NULL)
+                dma_direct_offset = SPIDER_DMA_OFFSET;
+
+        /* Now we need to check to see where the memory is mapped
+         * in PCI space. We assume that all busses use the same dma
+         * window which is always the case so far on Cell, thus we
+         * pick up the first pci-internal node we can find and check
+         * the DMA window from there.
+         */
+        for_each_node_by_name(np, "axon") {
+                if (np->parent == NULL || np->parent->parent != NULL)
+                        continue;
+                if (cell_iommu_get_window(np, &base, &size) == 0)
+                        break;
+        }
+        if (np == NULL) {
+                for_each_node_by_name(np, "pci-internal") {
+                        if (np->parent == NULL || np->parent->parent != NULL)
+                                continue;
+                        if (cell_iommu_get_window(np, &base, &size) == 0)
+                                break;
+                }
+        }
+        of_node_put(np);
+
+        /* If we found a DMA window, we check if it's big enough to enclose
+         * all of physical memory. If not, we force enable IOMMU
+         */
+        if (np && size < lmb_end_of_DRAM()) {
+                printk(KERN_WARNING "iommu: force-enabled, dma window"
+                       " (%ldMB) smaller than total memory (%ldMB)\n",
+                       size >> 20, lmb_end_of_DRAM() >> 20);
+                return -ENODEV;
+        }
 
-static dma_addr_t cell_map_single(struct device *hwdev, void *ptr,
-                size_t size, enum dma_data_direction direction)
-{
-        return virt_to_abs(ptr) | CELL_DMA_VALID;
-}
+        dma_direct_offset += base;
 
-static void cell_unmap_single(struct device *hwdev, dma_addr_t dma_addr,
-                size_t size, enum dma_data_direction direction)
-{
+        printk("iommu: disabled, direct DMA offset is 0x%lx\n",
+               dma_direct_offset);
+
+        return 0;
 }
 
-static int cell_map_sg(struct device *hwdev, struct scatterlist *sg,
-                int nents, enum dma_data_direction direction)
+static int __init cell_iommu_init(void)
 {
-        int i;
+        struct device_node *np;
+
+        if (!machine_is(cell))
+                return -ENODEV;
+
+        /* If IOMMU is disabled or we have little enough RAM to not need
+         * to enable it, we setup a direct mapping.
+         *
+         * Note: should we make sure we have the IOMMU actually disabled ?
+         */
+        if (iommu_is_off ||
+            (!iommu_force_on && lmb_end_of_DRAM() <= 0x80000000ull))
+                if (cell_iommu_init_disabled() == 0)
+                        goto bail;
+
+        /* Setup various ppc_md. callbacks */
+        ppc_md.pci_dma_dev_setup = cell_pci_dma_dev_setup;
+        ppc_md.tce_build = tce_build_cell;
+        ppc_md.tce_free = tce_free_cell;
+
+        /* Create an iommu for each /axon node.  */
+        for_each_node_by_name(np, "axon") {
+                if (np->parent == NULL || np->parent->parent != NULL)
+                        continue;
+                cell_iommu_init_one(np, 0);
+        }
 
-        for (i = 0; i < nents; i++, sg++) {
-                sg->dma_address = (page_to_phys(sg->page) + sg->offset)
-                                        | CELL_DMA_VALID;
-                sg->dma_length = sg->length;
+        /* Create an iommu for each toplevel /pci-internal node for
+         * old hardware/firmware
+         */
+        for_each_node_by_name(np, "pci-internal") {
+                if (np->parent == NULL || np->parent->parent != NULL)
+                        continue;
+                cell_iommu_init_one(np, SPIDER_DMA_OFFSET);
         }
 
-        return nents;
-}
+        /* Setup default PCI iommu ops */
+        pci_dma_ops = &dma_iommu_ops;
 
-static void cell_unmap_sg(struct device *hwdev, struct scatterlist *sg,
-                int nents, enum dma_data_direction direction)
-{
-}
+ bail:
+        /* Register callbacks on OF platform device addition/removal
+         * to handle linking them to the right DMA operations
+         */
+        bus_register_notifier(&of_platform_bus_type, &cell_of_bus_notifier);
 
-static int cell_dma_supported(struct device *dev, u64 mask)
-{
-        return mask < 0x100000000ull;
+        return 0;
 }
+arch_initcall(cell_iommu_init);
 
-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;
-
-        if (of_find_node_by_path("/mambo")) {
-                pr_info("Not using iommu on systemsim\n");
-        } else {
-
-                if (!(of_chosen &&
-                      get_property(of_chosen, "linux,iommu-off", NULL)))
-                        setup_bus = cell_map_iommu();
-
-                if (setup_bus) {
-                        pr_debug("%s: IOMMU mapping activated\n", __FUNCTION__);
-                        ppc_md.iommu_dev_setup = iommu_dev_setup_null;
-                        ppc_md.iommu_bus_setup = iommu_bus_setup;
-                } else {
-                        pr_debug("%s: IOMMU mapping activated, "
-                                 "no device action necessary\n", __FUNCTION__);
-                        /* Direct I/O, IOMMU off */
-                        ppc_md.iommu_dev_setup = iommu_dev_setup_null;
-                        ppc_md.iommu_bus_setup = iommu_bus_setup_null;
-                }
-        }
-
-        pci_dma_ops = cell_iommu_ops;
-}
diff --git a/arch/powerpc/platforms/cell/iommu.h b/arch/powerpc/platforms/cell/iommu.h
deleted file mode 100644
index 490d77abfe85..000000000000
--- a/arch/powerpc/platforms/cell/iommu.h
+++ /dev/null
@@ -1,65 +0,0 @@
-#ifndef CELL_IOMMU_H
-#define CELL_IOMMU_H
-
-/* some constants */
-enum {
-        /* segment table entries */
-        IOST_VALID_MASK   = 0x8000000000000000ul,
-        IOST_TAG_MASK     = 0x3000000000000000ul,
-        IOST_PT_BASE_MASK = 0x000003fffffff000ul,
-        IOST_NNPT_MASK    = 0x0000000000000fe0ul,
-        IOST_PS_MASK      = 0x000000000000000ful,
-
-        IOST_PS_4K        = 0x1,
-        IOST_PS_64K       = 0x3,
-        IOST_PS_1M        = 0x5,
-        IOST_PS_16M       = 0x7,
-
-        /* iopt tag register */
-        IOPT_VALID_MASK   = 0x0000000200000000ul,
-        IOPT_TAG_MASK     = 0x00000001fffffffful,
-
-        /* iopt cache register */
-        IOPT_PROT_MASK    = 0xc000000000000000ul,
-        IOPT_PROT_NONE    = 0x0000000000000000ul,
-        IOPT_PROT_READ    = 0x4000000000000000ul,
-        IOPT_PROT_WRITE   = 0x8000000000000000ul,
-        IOPT_PROT_RW      = 0xc000000000000000ul,
-        IOPT_COHERENT     = 0x2000000000000000ul,
-        
-        IOPT_ORDER_MASK   = 0x1800000000000000ul,
-        /* order access to same IOID/VC on same address */
-        IOPT_ORDER_ADDR   = 0x0800000000000000ul,
-        /* similar, but only after a write access */
-        IOPT_ORDER_WRITES = 0x1000000000000000ul,
-        /* Order all accesses to same IOID/VC */
-        IOPT_ORDER_VC     = 0x1800000000000000ul,
-        
-        IOPT_RPN_MASK     = 0x000003fffffff000ul,
-        IOPT_HINT_MASK    = 0x0000000000000800ul,
-        IOPT_IOID_MASK    = 0x00000000000007fful,
-
-        IOSTO_ENABLE      = 0x8000000000000000ul,
-        IOSTO_ORIGIN      = 0x000003fffffff000ul,
-        IOSTO_HW          = 0x0000000000000800ul,
-        IOSTO_SW          = 0x0000000000000400ul,
-
-        IOCMD_CONF_TE     = 0x0000800000000000ul,
-
-        /* memory mapped registers */
-        IOC_PT_CACHE_DIR  = 0x000,
-        IOC_ST_CACHE_DIR  = 0x800,
-        IOC_PT_CACHE_REG  = 0x910,
-        IOC_ST_ORIGIN     = 0x918,
-        IOC_CONF          = 0x930,
-
-        /* The high bit needs to be set on every DMA address,
-           only 2GB are addressable */
-        CELL_DMA_VALID    = 0x80000000,
-        CELL_DMA_MASK     = 0x7fffffff,
-};
-
-
-void cell_init_iommu(void);
-
-#endif
diff --git a/arch/powerpc/platforms/cell/pervasive.c b/arch/powerpc/platforms/cell/pervasive.c
index 9f2e4ed20a57..8c20f0fb8651 100644
--- a/arch/powerpc/platforms/cell/pervasive.c
+++ b/arch/powerpc/platforms/cell/pervasive.c
@@ -38,32 +38,25 @@
 #include "pervasive.h"
 #include "cbe_regs.h"
 
-static DEFINE_SPINLOCK(cbe_pervasive_lock);
-
-static void __init cbe_enable_pause_zero(void)
+static void cbe_power_save(void)
 {
-        unsigned long thread_switch_control;
-        unsigned long temp_register;
-        struct cbe_pmd_regs __iomem *pregs;
-
-        spin_lock_irq(&cbe_pervasive_lock);
-        pregs = cbe_get_cpu_pmd_regs(smp_processor_id());
-        if (pregs == NULL)
-                goto out;
+        unsigned long ctrl, thread_switch_control;
 
-        pr_debug("Power Management: CPU %d\n", smp_processor_id());
-
-         /* Enable Pause(0) control bit */
-        temp_register = in_be64(&pregs->pm_control);
+        /*
+         * We need to hard disable interrupts, but we also need to mark them
+         * hard disabled in the PACA so that the local_irq_enable() done by
+         * our caller upon return propertly hard enables.
+         */
+        hard_irq_disable();
+        get_paca()->hard_enabled = 0;
 
-        out_be64(&pregs->pm_control,
-                 temp_register | CBE_PMD_PAUSE_ZERO_CONTROL);
+        ctrl = mfspr(SPRN_CTRLF);
 
         /* Enable DEC and EE interrupt request */
         thread_switch_control  = mfspr(SPRN_TSC_CELL);
         thread_switch_control |= TSC_CELL_EE_ENABLE | TSC_CELL_EE_BOOST;
 
-        switch ((mfspr(SPRN_CTRLF) & CTRL_CT)) {
+        switch (ctrl & CTRL_CT) {
         case CTRL_CT0:
                 thread_switch_control |= TSC_CELL_DEC_ENABLE_0;
                 break;
@@ -75,58 +68,21 @@ static void __init cbe_enable_pause_zero(void)
                         __FUNCTION__);
                 break;
         }
-
         mtspr(SPRN_TSC_CELL, thread_switch_control);
 
-out:
-        spin_unlock_irq(&cbe_pervasive_lock);
-}
-
-static void cbe_idle(void)
-{
-        unsigned long ctrl;
+        /*
+         * go into low thread priority, medium priority will be
+         * restored for us after wake-up.
+         */
+        HMT_low();
 
-        /* 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
+        /*
+         * atomically disable thread execution and runlatch.
+         * External and Decrementer exceptions are still handled when the
+         * thread is disabled but now enter in cbe_system_reset_exception()
          */
-        cbe_enable_pause_zero();
-
-        while (1) {
-                if (!need_resched()) {
-                        local_irq_disable();
-                        while (!need_resched()) {
-                                /* go into low thread priority */
-                                HMT_low();
-
-                                /*
-                                 * atomically disable thread execution
-                                 * and runlatch.
-                                 * External and Decrementer exceptions
-                                 * are still handled when the thread
-                                 * is disabled but now enter in
-                                 * cbe_system_reset_exception()
-                                 */
-                                ctrl = mfspr(SPRN_CTRLF);
-                                ctrl &= ~(CTRL_RUNLATCH | CTRL_TE);
-                                mtspr(SPRN_CTRLT, ctrl);
-                        }
-                        /* restore thread prio */
-                        HMT_medium();
-                        local_irq_enable();
-                }
-
-                /*
-                 * turn runlatch on again before scheduling the
-                 * process we just woke up
-                 */
-                ppc64_runlatch_on();
-
-                preempt_enable_no_resched();
-                schedule();
-                preempt_disable();
-        }
+        ctrl &= ~(CTRL_RUNLATCH | CTRL_TE);
+        mtspr(SPRN_CTRLT, ctrl);
 }
 
 static int cbe_system_reset_exception(struct pt_regs *regs)
@@ -158,9 +114,20 @@ static int cbe_system_reset_exception(struct pt_regs *regs)
 
 void __init cbe_pervasive_init(void)
 {
+        int cpu;
         if (!cpu_has_feature(CPU_FTR_PAUSE_ZERO))
                 return;
 
-        ppc_md.idle_loop = cbe_idle;
+        for_each_possible_cpu(cpu) {
+                struct cbe_pmd_regs __iomem *regs = cbe_get_cpu_pmd_regs(cpu);
+                if (!regs)
+                        continue;
+
+                 /* Enable Pause(0) control bit */
+                out_be64(&regs->pmcr, in_be64(&regs->pmcr) |
+                                            CBE_PMD_PAUSE_ZERO_CONTROL);
+        }
+
+        ppc_md.power_save = cbe_power_save;
         ppc_md.system_reset_exception = cbe_system_reset_exception;
 }
diff --git a/arch/powerpc/platforms/cell/pmu.c b/arch/powerpc/platforms/cell/pmu.c
new file mode 100644
index 000000000000..d04ae1671e6c
--- /dev/null
+++ b/arch/powerpc/platforms/cell/pmu.c
@@ -0,0 +1,432 @@
+/*
+ * Cell Broadband Engine Performance Monitor
+ *
+ * (C) Copyright IBM Corporation 2001,2006
+ *
+ * Author:
+ *    David Erb (djerb@us.ibm.com)
+ *    Kevin Corry (kevcorry@us.ibm.com)
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <linux/interrupt.h>
+#include <linux/types.h>
+#include <asm/io.h>
+#include <asm/irq_regs.h>
+#include <asm/machdep.h>
+#include <asm/pmc.h>
+#include <asm/reg.h>
+#include <asm/spu.h>
+
+#include "cbe_regs.h"
+#include "interrupt.h"
+
+/*
+ * When writing to write-only mmio addresses, save a shadow copy. All of the
+ * registers are 32-bit, but stored in the upper-half of a 64-bit field in
+ * pmd_regs.
+ */
+
+#define WRITE_WO_MMIO(reg, x)                                   \
+        do {                                                    \
+                u32 _x = (x);                                   \
+                struct cbe_pmd_regs __iomem *pmd_regs;          \
+                struct cbe_pmd_shadow_regs *shadow_regs;        \
+                pmd_regs = cbe_get_cpu_pmd_regs(cpu);           \
+                shadow_regs = cbe_get_cpu_pmd_shadow_regs(cpu); \
+                out_be64(&(pmd_regs->reg), (((u64)_x) << 32));  \
+                shadow_regs->reg = _x;                          \
+        } while (0)
+
+#define READ_SHADOW_REG(val, reg)                               \
+        do {                                                    \
+                struct cbe_pmd_shadow_regs *shadow_regs;        \
+                shadow_regs = cbe_get_cpu_pmd_shadow_regs(cpu); \
+                (val) = shadow_regs->reg;                       \
+        } while (0)
+
+#define READ_MMIO_UPPER32(val, reg)                             \
+        do {                                                    \
+                struct cbe_pmd_regs __iomem *pmd_regs;          \
+                pmd_regs = cbe_get_cpu_pmd_regs(cpu);           \
+                (val) = (u32)(in_be64(&pmd_regs->reg) >> 32);   \
+        } while (0)
+
+/*
+ * Physical counter registers.
+ * Each physical counter can act as one 32-bit counter or two 16-bit counters.
+ */
+
+u32 cbe_read_phys_ctr(u32 cpu, u32 phys_ctr)
+{
+        u32 val_in_latch, val = 0;
+
+        if (phys_ctr < NR_PHYS_CTRS) {
+                READ_SHADOW_REG(val_in_latch, counter_value_in_latch);
+
+                /* Read the latch or the actual counter, whichever is newer. */
+                if (val_in_latch & (1 << phys_ctr)) {
+                        READ_SHADOW_REG(val, pm_ctr[phys_ctr]);
+                } else {
+                        READ_MMIO_UPPER32(val, pm_ctr[phys_ctr]);
+                }
+        }
+
+        return val;
+}
+EXPORT_SYMBOL_GPL(cbe_read_phys_ctr);
+
+void cbe_write_phys_ctr(u32 cpu, u32 phys_ctr, u32 val)
+{
+        struct cbe_pmd_shadow_regs *shadow_regs;
+        u32 pm_ctrl;
+
+        if (phys_ctr < NR_PHYS_CTRS) {
+                /* Writing to a counter only writes to a hardware latch.
+                 * The new value is not propagated to the actual counter
+                 * until the performance monitor is enabled.
+                 */
+                WRITE_WO_MMIO(pm_ctr[phys_ctr], val);
+
+                pm_ctrl = cbe_read_pm(cpu, pm_control);
+                if (pm_ctrl & CBE_PM_ENABLE_PERF_MON) {
+                        /* The counters are already active, so we need to
+                         * rewrite the pm_control register to "re-enable"
+                         * the PMU.
+                         */
+                        cbe_write_pm(cpu, pm_control, pm_ctrl);
+                } else {
+                        shadow_regs = cbe_get_cpu_pmd_shadow_regs(cpu);
+                        shadow_regs->counter_value_in_latch |= (1 << phys_ctr);
+                }
+        }
+}
+EXPORT_SYMBOL_GPL(cbe_write_phys_ctr);
+
+/*
+ * "Logical" counter registers.
+ * These will read/write 16-bits or 32-bits depending on the
+ * current size of the counter. Counters 4 - 7 are always 16-bit.
+ */
+
+u32 cbe_read_ctr(u32 cpu, u32 ctr)
+{
+        u32 val;
+        u32 phys_ctr = ctr & (NR_PHYS_CTRS - 1);
+
+        val = cbe_read_phys_ctr(cpu, phys_ctr);
+
+        if (cbe_get_ctr_size(cpu, phys_ctr) == 16)
+                val = (ctr < NR_PHYS_CTRS) ? (val >> 16) : (val & 0xffff);
+
+        return val;
+}
+EXPORT_SYMBOL_GPL(cbe_read_ctr);
+
+void cbe_write_ctr(u32 cpu, u32 ctr, u32 val)
+{
+        u32 phys_ctr;
+        u32 phys_val;
+
+        phys_ctr = ctr & (NR_PHYS_CTRS - 1);
+
+        if (cbe_get_ctr_size(cpu, phys_ctr) == 16) {
+                phys_val = cbe_read_phys_ctr(cpu, phys_ctr);
+
+                if (ctr < NR_PHYS_CTRS)
+                        val = (val << 16) | (phys_val & 0xffff);
+                else
+                        val = (val & 0xffff) | (phys_val & 0xffff0000);
+        }
+
+        cbe_write_phys_ctr(cpu, phys_ctr, val);
+}
+EXPORT_SYMBOL_GPL(cbe_write_ctr);
+
+/*
+ * Counter-control registers.
+ * Each "logical" counter has a corresponding control register.
+ */
+
+u32 cbe_read_pm07_control(u32 cpu, u32 ctr)
+{
+        u32 pm07_control = 0;
+
+        if (ctr < NR_CTRS)
+                READ_SHADOW_REG(pm07_control, pm07_control[ctr]);
+
+        return pm07_control;
+}
+EXPORT_SYMBOL_GPL(cbe_read_pm07_control);
+
+void cbe_write_pm07_control(u32 cpu, u32 ctr, u32 val)
+{
+        if (ctr < NR_CTRS)
+                WRITE_WO_MMIO(pm07_control[ctr], val);
+}
+EXPORT_SYMBOL_GPL(cbe_write_pm07_control);
+
+/*
+ * Other PMU control registers. Most of these are write-only.
+ */
+
+u32 cbe_read_pm(u32 cpu, enum pm_reg_name reg)
+{
+        u32 val = 0;
+
+        switch (reg) {
+        case group_control:
+                READ_SHADOW_REG(val, group_control);
+                break;
+
+        case debug_bus_control:
+                READ_SHADOW_REG(val, debug_bus_control);
+                break;
+
+        case trace_address:
+                READ_MMIO_UPPER32(val, trace_address);
+                break;
+
+        case ext_tr_timer:
+                READ_SHADOW_REG(val, ext_tr_timer);
+                break;
+
+        case pm_status:
+                READ_MMIO_UPPER32(val, pm_status);
+                break;
+
+        case pm_control:
+                READ_SHADOW_REG(val, pm_control);
+                break;
+
+        case pm_interval:
+                READ_SHADOW_REG(val, pm_interval);
+                break;
+
+        case pm_start_stop:
+                READ_SHADOW_REG(val, pm_start_stop);
+                break;
+        }
+
+        return val;
+}
+EXPORT_SYMBOL_GPL(cbe_read_pm);
+
+void cbe_write_pm(u32 cpu, enum pm_reg_name reg, u32 val)
+{
+        switch (reg) {
+        case group_control:
+                WRITE_WO_MMIO(group_control, val);
+                break;
+
+        case debug_bus_control:
+                WRITE_WO_MMIO(debug_bus_control, val);
+                break;
+
+        case trace_address:
+                WRITE_WO_MMIO(trace_address, val);
+                break;
+
+        case ext_tr_timer:
+                WRITE_WO_MMIO(ext_tr_timer, val);
+                break;
+
+        case pm_status:
+                WRITE_WO_MMIO(pm_status, val);
+                break;
+
+        case pm_control:
+                WRITE_WO_MMIO(pm_control, val);
+                break;
+
+        case pm_interval:
+                WRITE_WO_MMIO(pm_interval, val);
+                break;
+
+        case pm_start_stop:
+                WRITE_WO_MMIO(pm_start_stop, val);
+                break;
+        }
+}
+EXPORT_SYMBOL_GPL(cbe_write_pm);
+
+/*
+ * Get/set the size of a physical counter to either 16 or 32 bits.
+ */
+
+u32 cbe_get_ctr_size(u32 cpu, u32 phys_ctr)
+{
+        u32 pm_ctrl, size = 0;
+
+        if (phys_ctr < NR_PHYS_CTRS) {
+                pm_ctrl = cbe_read_pm(cpu, pm_control);
+                size = (pm_ctrl & CBE_PM_16BIT_CTR(phys_ctr)) ? 16 : 32;
+        }
+
+        return size;
+}
+EXPORT_SYMBOL_GPL(cbe_get_ctr_size);
+
+void cbe_set_ctr_size(u32 cpu, u32 phys_ctr, u32 ctr_size)
+{
+        u32 pm_ctrl;
+
+        if (phys_ctr < NR_PHYS_CTRS) {
+                pm_ctrl = cbe_read_pm(cpu, pm_control);
+                switch (ctr_size) {
+                case 16:
+                        pm_ctrl |= CBE_PM_16BIT_CTR(phys_ctr);
+                        break;
+
+                case 32:
+                        pm_ctrl &= ~CBE_PM_16BIT_CTR(phys_ctr);
+                        break;
+                }
+                cbe_write_pm(cpu, pm_control, pm_ctrl);
+        }
+}
+EXPORT_SYMBOL_GPL(cbe_set_ctr_size);
+
+/*
+ * Enable/disable the entire performance monitoring unit.
+ * When we enable the PMU, all pending writes to counters get committed.
+ */
+
+void cbe_enable_pm(u32 cpu)
+{
+        struct cbe_pmd_shadow_regs *shadow_regs;
+        u32 pm_ctrl;
+
+        shadow_regs = cbe_get_cpu_pmd_shadow_regs(cpu);
+        shadow_regs->counter_value_in_latch = 0;
+
+        pm_ctrl = cbe_read_pm(cpu, pm_control) | CBE_PM_ENABLE_PERF_MON;
+        cbe_write_pm(cpu, pm_control, pm_ctrl);
+}
+EXPORT_SYMBOL_GPL(cbe_enable_pm);
+
+void cbe_disable_pm(u32 cpu)
+{
+        u32 pm_ctrl;
+        pm_ctrl = cbe_read_pm(cpu, pm_control) & ~CBE_PM_ENABLE_PERF_MON;
+        cbe_write_pm(cpu, pm_control, pm_ctrl);
+}
+EXPORT_SYMBOL_GPL(cbe_disable_pm);
+
+/*
+ * Reading from the trace_buffer.
+ * The trace buffer is two 64-bit registers. Reading from
+ * the second half automatically increments the trace_address.
+ */
+
+void cbe_read_trace_buffer(u32 cpu, u64 *buf)
+{
+        struct cbe_pmd_regs __iomem *pmd_regs = cbe_get_cpu_pmd_regs(cpu);
+
+        *buf++ = in_be64(&pmd_regs->trace_buffer_0_63);
+        *buf++ = in_be64(&pmd_regs->trace_buffer_64_127);
+}
+EXPORT_SYMBOL_GPL(cbe_read_trace_buffer);
+
+/*
+ * Enabling/disabling interrupts for the entire performance monitoring unit.
+ */
+
+u32 cbe_query_pm_interrupts(u32 cpu)
+{
+        return cbe_read_pm(cpu, pm_status);
+}
+EXPORT_SYMBOL_GPL(cbe_query_pm_interrupts);
+
+u32 cbe_clear_pm_interrupts(u32 cpu)
+{
+        /* Reading pm_status clears the interrupt bits. */
+        return cbe_query_pm_interrupts(cpu);
+}
+EXPORT_SYMBOL_GPL(cbe_clear_pm_interrupts);
+
+void cbe_enable_pm_interrupts(u32 cpu, u32 thread, u32 mask)
+{
+        /* Set which node and thread will handle the next interrupt. */
+        iic_set_interrupt_routing(cpu, thread, 0);
+
+        /* Enable the interrupt bits in the pm_status register. */
+        if (mask)
+                cbe_write_pm(cpu, pm_status, mask);
+}
+EXPORT_SYMBOL_GPL(cbe_enable_pm_interrupts);
+
+void cbe_disable_pm_interrupts(u32 cpu)
+{
+        cbe_clear_pm_interrupts(cpu);
+        cbe_write_pm(cpu, pm_status, 0);
+}
+EXPORT_SYMBOL_GPL(cbe_disable_pm_interrupts);
+
+static irqreturn_t cbe_pm_irq(int irq, void *dev_id)
+{
+        perf_irq(get_irq_regs());
+        return IRQ_HANDLED;
+}
+
+static int __init cbe_init_pm_irq(void)
+{
+        unsigned int irq;
+        int rc, node;
+
+        if (!machine_is(cell))
+                return 0;
+
+        for_each_node(node) {
+                irq = irq_create_mapping(NULL, IIC_IRQ_IOEX_PMI |
+                                               (node << IIC_IRQ_NODE_SHIFT));
+                if (irq == NO_IRQ) {
+                        printk("ERROR: Unable to allocate irq for node %d\n",
+                               node);
+                        return -EINVAL;
+                }
+
+                rc = request_irq(irq, cbe_pm_irq,
+                                 IRQF_DISABLED, "cbe-pmu-0", NULL);
+                if (rc) {
+                        printk("ERROR: Request for irq on node %d failed\n",
+                               node);
+                        return rc;
+                }
+        }
+
+        return 0;
+}
+arch_initcall(cbe_init_pm_irq);
+
+void cbe_sync_irq(int node)
+{
+        unsigned int irq;
+
+        irq = irq_find_mapping(NULL,
+                               IIC_IRQ_IOEX_PMI
+                               | (node << IIC_IRQ_NODE_SHIFT));
+
+        if (irq == NO_IRQ) {
+                printk(KERN_WARNING "ERROR, unable to get existing irq %d " \
+                "for node %d\n", irq, node);
+                return;
+        }
+
+        synchronize_irq(irq);
+}
+EXPORT_SYMBOL_GPL(cbe_sync_irq);
+
diff --git a/arch/powerpc/platforms/cell/setup.c b/arch/powerpc/platforms/cell/setup.c
index 22c228a49c33..36989c2eee66 100644
--- a/arch/powerpc/platforms/cell/setup.c
+++ b/arch/powerpc/platforms/cell/setup.c
@@ -50,9 +50,10 @@
 #include <asm/spu.h>
 #include <asm/spu_priv1.h>
 #include <asm/udbg.h>
+#include <asm/mpic.h>
+#include <asm/of_platform.h>
 
 #include "interrupt.h"
-#include "iommu.h"
 #include "cbe_regs.h"
 #include "pervasive.h"
 #include "ras.h"
@@ -80,24 +81,72 @@ static void cell_progress(char *s, unsigned short hex)
         printk("*** %04x : %s\n", hex, s ? s : "");
 }
 
-static void __init cell_pcibios_fixup(void)
+static int __init cell_publish_devices(void)
 {
-        struct pci_dev *dev = NULL;
+        if (!machine_is(cell))
+                return 0;
+
+        /* Publish OF platform devices for southbridge IOs */
+        of_platform_bus_probe(NULL, NULL, NULL);
+
+        return 0;
+}
+device_initcall(cell_publish_devices);
+
+static void cell_mpic_cascade(unsigned int irq, struct irq_desc *desc)
+{
+        struct mpic *mpic = desc->handler_data;
+        unsigned int virq;
+
+        virq = mpic_get_one_irq(mpic);
+        if (virq != NO_IRQ)
+                generic_handle_irq(virq);
+        desc->chip->eoi(irq);
+}
 
-        for_each_pci_dev(dev)
-                pci_read_irq_line(dev);
+static void __init mpic_init_IRQ(void)
+{
+        struct device_node *dn;
+        struct mpic *mpic;
+        unsigned int virq;
+
+        for (dn = NULL;
+             (dn = of_find_node_by_name(dn, "interrupt-controller"));) {
+                if (!device_is_compatible(dn, "CBEA,platform-open-pic"))
+                        continue;
+
+                /* The MPIC driver will get everything it needs from the
+                 * device-tree, just pass 0 to all arguments
+                 */
+                mpic = mpic_alloc(dn, 0, 0, 0, 0, " MPIC     ");
+                if (mpic == NULL)
+                        continue;
+                mpic_init(mpic);
+
+                virq = irq_of_parse_and_map(dn, 0);
+                if (virq == NO_IRQ)
+                        continue;
+
+                printk(KERN_INFO "%s : hooking up to IRQ %d\n",
+                       dn->full_name, virq);
+                set_irq_data(virq, mpic);
+                set_irq_chained_handler(virq, cell_mpic_cascade);
+        }
 }
 
+
 static void __init cell_init_irq(void)
 {
         iic_init_IRQ();
         spider_init_IRQ();
+        mpic_init_IRQ();
 }
 
 static void __init cell_setup_arch(void)
 {
 #ifdef CONFIG_SPU_BASE
-        spu_priv1_ops         = &spu_priv1_mmio_ops;
+        spu_priv1_ops = &spu_priv1_mmio_ops;
+        spu_management_ops = &spu_management_of_ops;
 #endif
 
         cbe_regs_init();
@@ -109,7 +158,6 @@ static void __init cell_setup_arch(void)
 #ifdef CONFIG_SMP
         smp_init_cell();
 #endif
-
         /* init to some ~sane value until calibrate_delay() runs */
         loops_per_jiffy = 50000000;
 
@@ -129,19 +177,6 @@ static void __init cell_setup_arch(void)
         mmio_nvram_init();
 }
 
-/*
- * Early initialization.  Relocation is on but do not reference unbolted pages
- */
-static void __init cell_init_early(void)
-{
-        DBG(" -> cell_init_early()\n");
-
-        cell_init_iommu();
-
-        DBG(" <- cell_init_early()\n");
-}
-
-
 static int __init cell_probe(void)
 {
         unsigned long root = of_get_flat_dt_root();
@@ -168,7 +203,6 @@ define_machine(cell) {
         .name                   = "Cell",
         .probe                  = cell_probe,
         .setup_arch             = cell_setup_arch,
-        .init_early             = cell_init_early,
         .show_cpuinfo           = cell_show_cpuinfo,
         .restart                = rtas_restart,
         .power_off              = rtas_power_off,
@@ -180,7 +214,7 @@ define_machine(cell) {
         .check_legacy_ioport    = cell_check_legacy_ioport,
         .progress               = cell_progress,
         .init_IRQ               = cell_init_irq,
-        .pcibios_fixup          = cell_pcibios_fixup,
+        .pci_setup_phb          = rtas_setup_phb,
 #ifdef CONFIG_KEXEC
         .machine_kexec          = default_machine_kexec,
         .machine_kexec_prepare  = default_machine_kexec_prepare,
diff --git a/arch/powerpc/platforms/cell/spu_base.c b/arch/powerpc/platforms/cell/spu_base.c
index 7aa809d5a244..bd7bffc3ddd0 100644
--- a/arch/powerpc/platforms/cell/spu_base.c
+++ b/arch/powerpc/platforms/cell/spu_base.c
@@ -25,22 +25,17 @@
 #include <linux/interrupt.h>
 #include <linux/list.h>
 #include <linux/module.h>
-#include <linux/pci.h>
-#include <linux/poll.h>
 #include <linux/ptrace.h>
 #include <linux/slab.h>
 #include <linux/wait.h>
-
-#include <asm/firmware.h>
-#include <asm/io.h>
-#include <asm/prom.h>
+#include <linux/mm.h>
+#include <linux/io.h>
 #include <linux/mutex.h>
 #include <asm/spu.h>
 #include <asm/spu_priv1.h>
-#include <asm/mmu_context.h>
-
-#include "interrupt.h"
+#include <asm/xmon.h>
 
+const struct spu_management_ops *spu_management_ops;
 const struct spu_priv1_ops *spu_priv1_ops;
 
 EXPORT_SYMBOL_GPL(spu_priv1_ops);
@@ -89,7 +84,30 @@ static int __spu_trap_data_seg(struct spu *spu, unsigned long ea)
                 printk("%s: invalid access during switch!\n", __func__);
                 return 1;
         }
-        if (!mm || (REGION_ID(ea) != USER_REGION_ID)) {
+        esid = (ea & ESID_MASK) | SLB_ESID_V;
+
+        switch(REGION_ID(ea)) {
+        case USER_REGION_ID:
+#ifdef CONFIG_HUGETLB_PAGE
+                if (in_hugepage_area(mm->context, ea))
+                        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;
+                break;
+        case VMALLOC_REGION_ID:
+                llp = mmu_psize_defs[mmu_virtual_psize].sllp;
+                vsid = (get_kernel_vsid(ea) << SLB_VSID_SHIFT) |
+                        SLB_VSID_KERNEL | llp;
+                break;
+        case KERNEL_REGION_ID:
+                llp = mmu_psize_defs[mmu_linear_psize].sllp;
+                vsid = (get_kernel_vsid(ea) << SLB_VSID_SHIFT) |
+                        SLB_VSID_KERNEL | llp;
+                break;
+        default:
                 /* Future: support kernel segments so that drivers
                  * can use SPUs.
                  */
@@ -97,16 +115,6 @@ static int __spu_trap_data_seg(struct spu *spu, unsigned long ea)
                 return 1;
         }
 
-        esid = (ea & ESID_MASK) | SLB_ESID_V;
-#ifdef CONFIG_HUGETLB_PAGE
-        if (in_hugepage_area(mm->context, ea))
-                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);
         out_be64(&priv2->slb_esid_RW, esid);
@@ -320,6 +328,7 @@ static void spu_free_irqs(struct spu *spu)
 }
 
 static struct list_head spu_list[MAX_NUMNODES];
+static LIST_HEAD(spu_full_list);
 static DEFINE_MUTEX(spu_mutex);
 
 static void spu_init_channels(struct spu *spu)
@@ -364,8 +373,7 @@ struct spu *spu_alloc_node(int node)
         if (!list_empty(&spu_list[node])) {
                 spu = list_entry(spu_list[node].next, struct spu, list);
                 list_del_init(&spu->list);
-                pr_debug("Got SPU %x %d %d\n",
-                         spu->isrc, spu->number, spu->node);
+                pr_debug("Got SPU %d %d\n", spu->number, spu->node);
                 spu_init_channels(spu);
         }
         mutex_unlock(&spu_mutex);
@@ -493,280 +501,65 @@ int spu_irq_class_1_bottom(struct spu *spu)
         if (!error) {
                 spu_restart_dma(spu);
         } else {
-                __spu_trap_invalid_dma(spu);
+                spu->dma_callback(spu, SPE_EVENT_SPE_DATA_STORAGE);
         }
         return ret;
 }
 
-static int __init find_spu_node_id(struct device_node *spe)
-{
-        const unsigned int *id;
-        struct device_node *cpu;
-        cpu = spe->parent->parent;
-        id = get_property(cpu, "node-id", NULL);
-        return id ? *id : 0;
-}
-
-static int __init cell_spuprop_present(struct spu *spu, struct device_node *spe,
-                const char *prop)
-{
-        static DEFINE_MUTEX(add_spumem_mutex);
-
-        const struct address_prop {
-                unsigned long address;
-                unsigned int len;
-        } __attribute__((packed)) *p;
-        int proplen;
-
-        unsigned long start_pfn, nr_pages;
-        struct pglist_data *pgdata;
-        struct zone *zone;
-        int ret;
-
-        p = get_property(spe, prop, &proplen);
-        WARN_ON(proplen != sizeof (*p));
-
-        start_pfn = p->address >> PAGE_SHIFT;
-        nr_pages = ((unsigned long)p->len + PAGE_SIZE - 1) >> PAGE_SHIFT;
-
-        pgdata = NODE_DATA(spu->nid);
-        zone = pgdata->node_zones;
-
-        /* XXX rethink locking here */
-        mutex_lock(&add_spumem_mutex);
-        ret = __add_pages(zone, start_pfn, nr_pages);
-        mutex_unlock(&add_spumem_mutex);
-
-        return ret;
-}
+struct sysdev_class spu_sysdev_class = {
+        set_kset_name("spu")
+};
 
-static void __iomem * __init map_spe_prop(struct spu *spu,
-                struct device_node *n, const char *name)
+int spu_add_sysdev_attr(struct sysdev_attribute *attr)
 {
-        const struct address_prop {
-                unsigned long address;
-                unsigned int len;
-        } __attribute__((packed)) *prop;
-
-        const void *p;
-        int proplen;
-        void __iomem *ret = NULL;
-        int err = 0;
-
-        p = get_property(n, name, &proplen);
-        if (proplen != sizeof (struct address_prop))
-                return NULL;
-
-        prop = p;
-
-        err = cell_spuprop_present(spu, n, name);
-        if (err && (err != -EEXIST))
-                goto out;
-
-        ret = ioremap(prop->address, prop->len);
-
- out:
-        return ret;
-}
+        struct spu *spu;
+        mutex_lock(&spu_mutex);
 
-static void spu_unmap(struct spu *spu)
-{
-        iounmap(spu->priv2);
-        iounmap(spu->priv1);
-        iounmap(spu->problem);
-        iounmap((__force u8 __iomem *)spu->local_store);
-}
+        list_for_each_entry(spu, &spu_full_list, full_list)
+                sysdev_create_file(&spu->sysdev, attr);
 
-/* This function shall be abstracted for HV platforms */
-static int __init spu_map_interrupts_old(struct spu *spu, struct device_node *np)
-{
-        unsigned int isrc;
-        const u32 *tmp;
-
-        /* Get the interrupt source unit from the device-tree */
-        tmp = get_property(np, "isrc", NULL);
-        if (!tmp)
-                return -ENODEV;
-        isrc = tmp[0];
-
-        /* Add the node number */
-        isrc |= spu->node << IIC_IRQ_NODE_SHIFT;
-        spu->isrc = isrc;
-
-        /* Now map interrupts of all 3 classes */
-        spu->irqs[0] = irq_create_mapping(NULL, IIC_IRQ_CLASS_0 | isrc);
-        spu->irqs[1] = irq_create_mapping(NULL, IIC_IRQ_CLASS_1 | isrc);
-        spu->irqs[2] = irq_create_mapping(NULL, IIC_IRQ_CLASS_2 | isrc);
-
-        /* Right now, we only fail if class 2 failed */
-        return spu->irqs[2] == NO_IRQ ? -EINVAL : 0;
+        mutex_unlock(&spu_mutex);
+        return 0;
 }
+EXPORT_SYMBOL_GPL(spu_add_sysdev_attr);
 
-static int __init spu_map_device_old(struct spu *spu, struct device_node *node)
+int spu_add_sysdev_attr_group(struct attribute_group *attrs)
 {
-        const char *prop;
-        int ret;
-
-        ret = -ENODEV;
-        spu->name = get_property(node, "name", NULL);
-        if (!spu->name)
-                goto out;
-
-        prop = get_property(node, "local-store", NULL);
-        if (!prop)
-                goto out;
-        spu->local_store_phys = *(unsigned long *)prop;
-
-        /* we use local store as ram, not io memory */
-        spu->local_store = (void __force *)
-                map_spe_prop(spu, node, "local-store");
-        if (!spu->local_store)
-                goto out;
-
-        prop = get_property(node, "problem", NULL);
-        if (!prop)
-                goto out_unmap;
-        spu->problem_phys = *(unsigned long *)prop;
-
-        spu->problem= map_spe_prop(spu, node, "problem");
-        if (!spu->problem)
-                goto out_unmap;
-
-        spu->priv1= map_spe_prop(spu, node, "priv1");
-        /* priv1 is not available on a hypervisor */
-
-        spu->priv2= map_spe_prop(spu, node, "priv2");
-        if (!spu->priv2)
-                goto out_unmap;
-        ret = 0;
-        goto out;
-
-out_unmap:
-        spu_unmap(spu);
-out:
-        return ret;
-}
+        struct spu *spu;
+        mutex_lock(&spu_mutex);
 
-static int __init spu_map_interrupts(struct spu *spu, struct device_node *np)
-{
-        struct of_irq oirq;
-        int ret;
-        int i;
+        list_for_each_entry(spu, &spu_full_list, full_list)
+                sysfs_create_group(&spu->sysdev.kobj, attrs);
 
-        for (i=0; i < 3; i++) {
-                ret = of_irq_map_one(np, i, &oirq);
-                if (ret) {
-                        pr_debug("spu_new: failed to get irq %d\n", i);
-                        goto err;
-                }
-                ret = -EINVAL;
-                pr_debug("  irq %d no 0x%x on %s\n", i, oirq.specifier[0],
-                         oirq.controller->full_name);
-                spu->irqs[i] = irq_create_of_mapping(oirq.controller,
-                                        oirq.specifier, oirq.size);
-                if (spu->irqs[i] == NO_IRQ) {
-                        pr_debug("spu_new: failed to map it !\n");
-                        goto err;
-                }
-        }
+        mutex_unlock(&spu_mutex);
         return 0;
-
-err:
-        pr_debug("failed to map irq %x for spu %s\n", *oirq.specifier, spu->name);
-        for (; i >= 0; i--) {
-                if (spu->irqs[i] != NO_IRQ)
-                        irq_dispose_mapping(spu->irqs[i]);
-        }
-        return ret;
 }
+EXPORT_SYMBOL_GPL(spu_add_sysdev_attr_group);
 
-static int spu_map_resource(struct device_node *node, int nr,
-                void __iomem** virt, unsigned long *phys)
-{
-        struct resource resource = { };
-        int ret;
-
-        ret = of_address_to_resource(node, nr, &resource);
-        if (ret)
-                goto out;
 
-        if (phys)
-                *phys = resource.start;
-        *virt = ioremap(resource.start, resource.end - resource.start);
-        if (!*virt)
-                ret = -EINVAL;
-
-out:
-        return ret;
-}
-
-static int __init spu_map_device(struct spu *spu, struct device_node *node)
+void spu_remove_sysdev_attr(struct sysdev_attribute *attr)
 {
-        int ret = -ENODEV;
-        spu->name = get_property(node, "name", NULL);
-        if (!spu->name)
-                goto out;
-
-        ret = spu_map_resource(node, 0, (void __iomem**)&spu->local_store,
-                                        &spu->local_store_phys);
-        if (ret) {
-                pr_debug("spu_new: failed to map %s resource 0\n",
-                         node->full_name);
-                goto out;
-        }
-        ret = spu_map_resource(node, 1, (void __iomem**)&spu->problem,
-                                        &spu->problem_phys);
-        if (ret) {
-                pr_debug("spu_new: failed to map %s resource 1\n",
-                         node->full_name);
-                goto out_unmap;
-        }
-        ret = spu_map_resource(node, 2, (void __iomem**)&spu->priv2,
-                                        NULL);
-        if (ret) {
-                pr_debug("spu_new: failed to map %s resource 2\n",
-                         node->full_name);
-                goto out_unmap;
-        }
-
-        if (!firmware_has_feature(FW_FEATURE_LPAR))
-                ret = spu_map_resource(node, 3, (void __iomem**)&spu->priv1,
-                                        NULL);
-        if (ret) {
-                pr_debug("spu_new: failed to map %s resource 3\n",
-                         node->full_name);
-                goto out_unmap;
-        }
-        pr_debug("spu_new: %s maps:\n", node->full_name);
-        pr_debug("  local store   : 0x%016lx -> 0x%p\n",
-                 spu->local_store_phys, spu->local_store);
-        pr_debug("  problem state : 0x%016lx -> 0x%p\n",
-                 spu->problem_phys, spu->problem);
-        pr_debug("  priv2         :                       0x%p\n", spu->priv2);
-        pr_debug("  priv1         :                       0x%p\n", spu->priv1);
+        struct spu *spu;
+        mutex_lock(&spu_mutex);
 
-        return 0;
+        list_for_each_entry(spu, &spu_full_list, full_list)
+                sysdev_remove_file(&spu->sysdev, attr);
 
-out_unmap:
-        spu_unmap(spu);
-out:
-        pr_debug("failed to map spe %s: %d\n", spu->name, ret);
-        return ret;
+        mutex_unlock(&spu_mutex);
 }
+EXPORT_SYMBOL_GPL(spu_remove_sysdev_attr);
 
-struct sysdev_class spu_sysdev_class = {
-        set_kset_name("spu")
-};
-
-static ssize_t spu_show_isrc(struct sys_device *sysdev, char *buf)
+void spu_remove_sysdev_attr_group(struct attribute_group *attrs)
 {
-        struct spu *spu = container_of(sysdev, struct spu, sysdev);
-        return sprintf(buf, "%d\n", spu->isrc);
+        struct spu *spu;
+        mutex_lock(&spu_mutex);
 
-}
-static SYSDEV_ATTR(isrc, 0400, spu_show_isrc, NULL);
+        list_for_each_entry(spu, &spu_full_list, full_list)
+                sysfs_remove_group(&spu->sysdev.kobj, attrs);
 
-extern int attach_sysdev_to_node(struct sys_device *dev, int nid);
+        mutex_unlock(&spu_mutex);
+}
+EXPORT_SYMBOL_GPL(spu_remove_sysdev_attr_group);
 
 static int spu_create_sysdev(struct spu *spu)
 {
@@ -781,21 +574,18 @@ static int spu_create_sysdev(struct spu *spu)
                 return ret;
         }
 
-        if (spu->isrc != 0)
-                sysdev_create_file(&spu->sysdev, &attr_isrc);
-        sysfs_add_device_to_node(&spu->sysdev, spu->nid);
+        sysfs_add_device_to_node(&spu->sysdev, spu->node);
 
         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);
+        sysfs_remove_device_from_node(&spu->sysdev, spu->node);
         sysdev_unregister(&spu->sysdev);
 }
 
-static int __init create_spu(struct device_node *spe)
+static int __init create_spu(void *data)
 {
         struct spu *spu;
         int ret;
@@ -806,57 +596,37 @@ static int __init create_spu(struct device_node *spe)
         if (!spu)
                 goto out;
 
-        spu->node = find_spu_node_id(spe);
-        if (spu->node >= MAX_NUMNODES) {
-                printk(KERN_WARNING "SPE %s on node %d ignored,"
-                       " node number too big\n", spe->full_name, spu->node);
-                printk(KERN_WARNING "Check if CONFIG_NUMA is enabled.\n");
-                return -ENODEV;
-        }
-        spu->nid = of_node_to_nid(spe);
-        if (spu->nid == -1)
-                spu->nid = 0;
+        spin_lock_init(&spu->register_lock);
+        mutex_lock(&spu_mutex);
+        spu->number = number++;
+        mutex_unlock(&spu_mutex);
+
+        ret = spu_create_spu(spu, data);
 
-        ret = spu_map_device(spu, spe);
-        /* try old method */
-        if (ret)
-                ret = spu_map_device_old(spu, spe);
         if (ret)
                 goto out_free;
 
-        ret = spu_map_interrupts(spu, spe);
-        if (ret)
-                ret = spu_map_interrupts_old(spu, spe);
-        if (ret)
-                goto out_unmap;
-        spin_lock_init(&spu->register_lock);
-        spu_mfc_sdr_set(spu, mfspr(SPRN_SDR1));
+        spu_mfc_sdr_setup(spu);
         spu_mfc_sr1_set(spu, 0x33);
-        mutex_lock(&spu_mutex);
-
-        spu->number = number++;
         ret = spu_request_irqs(spu);
         if (ret)
-                goto out_unlock;
+                goto out_destroy;
 
         ret = spu_create_sysdev(spu);
         if (ret)
                 goto out_free_irqs;
 
+        mutex_lock(&spu_mutex);
         list_add(&spu->list, &spu_list[spu->node]);
+        list_add(&spu->full_list, &spu_full_list);
         mutex_unlock(&spu_mutex);
 
-        pr_debug(KERN_DEBUG "Using SPE %s %02x %p %p %p %p %d\n",
-                spu->name, spu->isrc, spu->local_store,
-                spu->problem, spu->priv1, spu->priv2, spu->number);
         goto out;
 
 out_free_irqs:
         spu_free_irqs(spu);
-out_unlock:
-        mutex_unlock(&spu_mutex);
-out_unmap:
-        spu_unmap(spu);
+out_destroy:
+        spu_destroy_spu(spu);
 out_free:
         kfree(spu);
 out:
@@ -866,10 +636,11 @@ out:
 static void destroy_spu(struct spu *spu)
 {
         list_del_init(&spu->list);
+        list_del_init(&spu->full_list);
 
         spu_destroy_sysdev(spu);
         spu_free_irqs(spu);
-        spu_unmap(spu);
+        spu_destroy_spu(spu);
         kfree(spu);
 }
 
@@ -890,9 +661,11 @@ module_exit(cleanup_spu_base);
 
 static int __init init_spu_base(void)
 {
-        struct device_node *node;
         int i, ret;
 
+        if (!spu_management_ops)
+                return 0;
+
         /* create sysdev class for spus */
         ret = sysdev_class_register(&spu_sysdev_class);
         if (ret)
@@ -901,17 +674,17 @@ static int __init init_spu_base(void)
         for (i = 0; i < MAX_NUMNODES; i++)
                 INIT_LIST_HEAD(&spu_list[i]);
 
-        ret = -ENODEV;
-        for (node = of_find_node_by_type(NULL, "spe");
-                        node; node = of_find_node_by_type(node, "spe")) {
-                ret = create_spu(node);
-                if (ret) {
-                        printk(KERN_WARNING "%s: Error initializing %s\n",
-                                __FUNCTION__, node->name);
-                        cleanup_spu_base();
-                        break;
-                }
+        ret = spu_enumerate_spus(create_spu);
+
+        if (ret) {
+                printk(KERN_WARNING "%s: Error initializing spus\n",
+                        __FUNCTION__);
+                cleanup_spu_base();
+                return ret;
         }
+
+        xmon_register_spus(&spu_full_list);
+
         return ret;
 }
 module_init(init_spu_base);
diff --git a/arch/powerpc/platforms/cell/spu_coredump.c b/arch/powerpc/platforms/cell/spu_coredump.c
new file mode 100644
index 000000000000..6915b418ee73
--- /dev/null
+++ b/arch/powerpc/platforms/cell/spu_coredump.c
@@ -0,0 +1,81 @@
+/*
+ * SPU core dump code
+ *
+ * (C) Copyright 2006 IBM Corp.
+ *
+ * Author: Dwayne Grant McConnell <decimal@us.ibm.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <linux/file.h>
+#include <linux/module.h>
+#include <linux/syscalls.h>
+
+#include <asm/spu.h>
+
+static struct spu_coredump_calls spu_coredump_calls;
+static DEFINE_MUTEX(spu_coredump_mutex);
+
+int arch_notes_size(void)
+{
+        long ret;
+        struct module *owner = spu_coredump_calls.owner;
+
+        ret = -ENOSYS;
+        mutex_lock(&spu_coredump_mutex);
+        if (owner && try_module_get(owner)) {
+                ret = spu_coredump_calls.arch_notes_size();
+                module_put(owner);
+        }
+        mutex_unlock(&spu_coredump_mutex);
+        return ret;
+}
+
+void arch_write_notes(struct file *file)
+{
+        struct module *owner = spu_coredump_calls.owner;
+
+        mutex_lock(&spu_coredump_mutex);
+        if (owner && try_module_get(owner)) {
+                spu_coredump_calls.arch_write_notes(file);
+                module_put(owner);
+        }
+        mutex_unlock(&spu_coredump_mutex);
+}
+
+int register_arch_coredump_calls(struct spu_coredump_calls *calls)
+{
+        if (spu_coredump_calls.owner)
+                return -EBUSY;
+
+        mutex_lock(&spu_coredump_mutex);
+        spu_coredump_calls.arch_notes_size = calls->arch_notes_size;
+        spu_coredump_calls.arch_write_notes = calls->arch_write_notes;
+        spu_coredump_calls.owner = calls->owner;
+        mutex_unlock(&spu_coredump_mutex);
+        return 0;
+}
+EXPORT_SYMBOL_GPL(register_arch_coredump_calls);
+
+void unregister_arch_coredump_calls(struct spu_coredump_calls *calls)
+{
+        BUG_ON(spu_coredump_calls.owner != calls->owner);
+
+        mutex_lock(&spu_coredump_mutex);
+        spu_coredump_calls.owner = NULL;
+        mutex_unlock(&spu_coredump_mutex);
+}
+EXPORT_SYMBOL_GPL(unregister_arch_coredump_calls);
diff --git a/arch/powerpc/platforms/cell/spu_priv1_mmio.c b/arch/powerpc/platforms/cell/spu_priv1_mmio.c
index 71b69f0a1a48..910a926b61a2 100644
--- a/arch/powerpc/platforms/cell/spu_priv1_mmio.c
+++ b/arch/powerpc/platforms/cell/spu_priv1_mmio.c
@@ -18,120 +18,509 @@
  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
+#include <linux/interrupt.h>
+#include <linux/list.h>
 #include <linux/module.h>
+#include <linux/ptrace.h>
+#include <linux/slab.h>
+#include <linux/wait.h>
+#include <linux/mm.h>
+#include <linux/io.h>
+#include <linux/mutex.h>
+#include <linux/device.h>
 
-#include <asm/io.h>
 #include <asm/spu.h>
 #include <asm/spu_priv1.h>
+#include <asm/firmware.h>
+#include <asm/prom.h>
 
 #include "interrupt.h"
+#include "spu_priv1_mmio.h"
+
+static DEFINE_MUTEX(add_spumem_mutex);
+
+struct spu_pdata {
+        struct device_node *devnode;
+        struct spu_priv1 __iomem *priv1;
+};
+
+static struct spu_pdata *spu_get_pdata(struct spu *spu)
+{
+        BUG_ON(!spu->pdata);
+        return spu->pdata;
+}
+
+struct device_node *spu_devnode(struct spu *spu)
+{
+        return spu_get_pdata(spu)->devnode;
+}
+
+EXPORT_SYMBOL_GPL(spu_devnode);
+
+static int __init cell_spuprop_present(struct spu *spu, struct device_node *spe,
+                const char *prop)
+{
+        const struct address_prop {
+                unsigned long address;
+                unsigned int len;
+        } __attribute__((packed)) *p;
+        int proplen;
+
+        unsigned long start_pfn, nr_pages;
+        struct pglist_data *pgdata;
+        struct zone *zone;
+        int ret;
+
+        p = get_property(spe, prop, &proplen);
+        WARN_ON(proplen != sizeof (*p));
+
+        start_pfn = p->address >> PAGE_SHIFT;
+        nr_pages = ((unsigned long)p->len + PAGE_SIZE - 1) >> PAGE_SHIFT;
+
+        pgdata = NODE_DATA(spu->node);
+        zone = pgdata->node_zones;
+
+        /* XXX rethink locking here */
+        mutex_lock(&add_spumem_mutex);
+        ret = __add_pages(zone, start_pfn, nr_pages);
+        mutex_unlock(&add_spumem_mutex);
+
+        return ret;
+}
+
+static void __iomem * __init map_spe_prop(struct spu *spu,
+                struct device_node *n, const char *name)
+{
+        const struct address_prop {
+                unsigned long address;
+                unsigned int len;
+        } __attribute__((packed)) *prop;
+
+        const void *p;
+        int proplen;
+        void __iomem *ret = NULL;
+        int err = 0;
+
+        p = get_property(n, name, &proplen);
+        if (proplen != sizeof (struct address_prop))
+                return NULL;
+
+        prop = p;
+
+        err = cell_spuprop_present(spu, n, name);
+        if (err && (err != -EEXIST))
+                goto out;
+
+        ret = ioremap(prop->address, prop->len);
+
+ out:
+        return ret;
+}
+
+static void spu_unmap(struct spu *spu)
+{
+        iounmap(spu->priv2);
+        iounmap(spu_get_pdata(spu)->priv1);
+        iounmap(spu->problem);
+        iounmap((__force u8 __iomem *)spu->local_store);
+}
+
+static int __init spu_map_interrupts_old(struct spu *spu,
+        struct device_node *np)
+{
+        unsigned int isrc;
+        const u32 *tmp;
+        int nid;
+
+        /* Get the interrupt source unit from the device-tree */
+        tmp = get_property(np, "isrc", NULL);
+        if (!tmp)
+                return -ENODEV;
+        isrc = tmp[0];
+
+        tmp = get_property(np->parent->parent, "node-id", NULL);
+        if (!tmp) {
+                printk(KERN_WARNING "%s: can't find node-id\n", __FUNCTION__);
+                nid = spu->node;
+        } else
+                nid = tmp[0];
+
+        /* Add the node number */
+        isrc |= nid << IIC_IRQ_NODE_SHIFT;
+
+        /* Now map interrupts of all 3 classes */
+        spu->irqs[0] = irq_create_mapping(NULL, IIC_IRQ_CLASS_0 | isrc);
+        spu->irqs[1] = irq_create_mapping(NULL, IIC_IRQ_CLASS_1 | isrc);
+        spu->irqs[2] = irq_create_mapping(NULL, IIC_IRQ_CLASS_2 | isrc);
+
+        /* Right now, we only fail if class 2 failed */
+        return spu->irqs[2] == NO_IRQ ? -EINVAL : 0;
+}
+
+static int __init spu_map_device_old(struct spu *spu, struct device_node *node)
+{
+        const char *prop;
+        int ret;
+
+        ret = -ENODEV;
+        spu->name = get_property(node, "name", NULL);
+        if (!spu->name)
+                goto out;
+
+        prop = get_property(node, "local-store", NULL);
+        if (!prop)
+                goto out;
+        spu->local_store_phys = *(unsigned long *)prop;
+
+        /* we use local store as ram, not io memory */
+        spu->local_store = (void __force *)
+                map_spe_prop(spu, node, "local-store");
+        if (!spu->local_store)
+                goto out;
+
+        prop = get_property(node, "problem", NULL);
+        if (!prop)
+                goto out_unmap;
+        spu->problem_phys = *(unsigned long *)prop;
+
+        spu->problem= map_spe_prop(spu, node, "problem");
+        if (!spu->problem)
+                goto out_unmap;
+
+        spu_get_pdata(spu)->priv1= map_spe_prop(spu, node, "priv1");
+
+        spu->priv2= map_spe_prop(spu, node, "priv2");
+        if (!spu->priv2)
+                goto out_unmap;
+        ret = 0;
+        goto out;
+
+out_unmap:
+        spu_unmap(spu);
+out:
+        return ret;
+}
+
+static int __init spu_map_interrupts(struct spu *spu, struct device_node *np)
+{
+        struct of_irq oirq;
+        int ret;
+        int i;
+
+        for (i=0; i < 3; i++) {
+                ret = of_irq_map_one(np, i, &oirq);
+                if (ret) {
+                        pr_debug("spu_new: failed to get irq %d\n", i);
+                        goto err;
+                }
+                ret = -EINVAL;
+                pr_debug("  irq %d no 0x%x on %s\n", i, oirq.specifier[0],
+                         oirq.controller->full_name);
+                spu->irqs[i] = irq_create_of_mapping(oirq.controller,
+                                        oirq.specifier, oirq.size);
+                if (spu->irqs[i] == NO_IRQ) {
+                        pr_debug("spu_new: failed to map it !\n");
+                        goto err;
+                }
+        }
+        return 0;
+
+err:
+        pr_debug("failed to map irq %x for spu %s\n", *oirq.specifier,
+                spu->name);
+        for (; i >= 0; i--) {
+                if (spu->irqs[i] != NO_IRQ)
+                        irq_dispose_mapping(spu->irqs[i]);
+        }
+        return ret;
+}
+
+static int spu_map_resource(struct spu *spu, int nr,
+                            void __iomem** virt, unsigned long *phys)
+{
+        struct device_node *np = spu_get_pdata(spu)->devnode;
+        unsigned long start_pfn, nr_pages;
+        struct pglist_data *pgdata;
+        struct zone *zone;
+        struct resource resource = { };
+        unsigned long len;
+        int ret;
+
+        ret = of_address_to_resource(np, nr, &resource);
+        if (ret)
+                goto out;
+
+        if (phys)
+                *phys = resource.start;
+        len = resource.end - resource.start + 1;
+        *virt = ioremap(resource.start, len);
+        if (!*virt)
+                ret = -EINVAL;
+
+        start_pfn = resource.start >> PAGE_SHIFT;
+        nr_pages = (len + PAGE_SIZE - 1) >> PAGE_SHIFT;
+
+        pgdata = NODE_DATA(spu->node);
+        zone = pgdata->node_zones;
+
+        /* XXX rethink locking here */
+        mutex_lock(&add_spumem_mutex);
+        ret = __add_pages(zone, start_pfn, nr_pages);
+        mutex_unlock(&add_spumem_mutex);
+
+out:
+        return ret;
+}
+
+static int __init spu_map_device(struct spu *spu)
+{
+        struct device_node *np = spu_get_pdata(spu)->devnode;
+        int ret = -ENODEV;
+
+        spu->name = get_property(np, "name", NULL);
+        if (!spu->name)
+                goto out;
+
+        ret = spu_map_resource(spu, 0, (void __iomem**)&spu->local_store,
+                               &spu->local_store_phys);
+        if (ret) {
+                pr_debug("spu_new: failed to map %s resource 0\n",
+                         np->full_name);
+                goto out;
+        }
+        ret = spu_map_resource(spu, 1, (void __iomem**)&spu->problem,
+                               &spu->problem_phys);
+        if (ret) {
+                pr_debug("spu_new: failed to map %s resource 1\n",
+                         np->full_name);
+                goto out_unmap;
+        }
+        ret = spu_map_resource(spu, 2, (void __iomem**)&spu->priv2, NULL);
+        if (ret) {
+                pr_debug("spu_new: failed to map %s resource 2\n",
+                         np->full_name);
+                goto out_unmap;
+        }
+        if (!firmware_has_feature(FW_FEATURE_LPAR))
+                ret = spu_map_resource(spu, 3,
+                               (void __iomem**)&spu_get_pdata(spu)->priv1, NULL);
+        if (ret) {
+                pr_debug("spu_new: failed to map %s resource 3\n",
+                         np->full_name);
+                goto out_unmap;
+        }
+        pr_debug("spu_new: %s maps:\n", np->full_name);
+        pr_debug("  local store   : 0x%016lx -> 0x%p\n",
+                 spu->local_store_phys, spu->local_store);
+        pr_debug("  problem state : 0x%016lx -> 0x%p\n",
+                 spu->problem_phys, spu->problem);
+        pr_debug("  priv2         :                       0x%p\n", spu->priv2);
+        pr_debug("  priv1         :                       0x%p\n",
+                 spu_get_pdata(spu)->priv1);
+
+        return 0;
+
+out_unmap:
+        spu_unmap(spu);
+out:
+        pr_debug("failed to map spe %s: %d\n", spu->name, ret);
+        return ret;
+}
+
+static int __init of_enumerate_spus(int (*fn)(void *data))
+{
+        int ret;
+        struct device_node *node;
+
+        ret = -ENODEV;
+        for (node = of_find_node_by_type(NULL, "spe");
+                        node; node = of_find_node_by_type(node, "spe")) {
+                ret = fn(node);
+                if (ret) {
+                        printk(KERN_WARNING "%s: Error initializing %s\n",
+                                __FUNCTION__, node->name);
+                        break;
+                }
+        }
+        return ret;
+}
+
+static int __init of_create_spu(struct spu *spu, void *data)
+{
+        int ret;
+        struct device_node *spe = (struct device_node *)data;
+
+        spu->pdata = kzalloc(sizeof(struct spu_pdata),
+                GFP_KERNEL);
+        if (!spu->pdata) {
+                ret = -ENOMEM;
+                goto out;
+        }
+        spu_get_pdata(spu)->devnode = of_node_get(spe);
+
+        spu->node = of_node_to_nid(spe);
+        if (spu->node >= MAX_NUMNODES) {
+                printk(KERN_WARNING "SPE %s on node %d ignored,"
+                       " node number too big\n", spe->full_name, spu->node);
+                printk(KERN_WARNING "Check if CONFIG_NUMA is enabled.\n");
+                ret = -ENODEV;
+                goto out_free;
+        }
+
+        ret = spu_map_device(spu);
+        /* try old method */
+        if (ret)
+                ret = spu_map_device_old(spu, spe);
+        if (ret)
+                goto out_free;
+
+        ret = spu_map_interrupts(spu, spe);
+        if (ret)
+                ret = spu_map_interrupts_old(spu, spe);
+        if (ret)
+                goto out_unmap;
+
+        pr_debug(KERN_DEBUG "Using SPE %s %p %p %p %p %d\n", spu->name,
+                spu->local_store, spu->problem, spu_get_pdata(spu)->priv1,
+                spu->priv2, spu->number);
+        goto out;
+
+out_unmap:
+        spu_unmap(spu);
+out_free:
+        kfree(spu->pdata);
+        spu->pdata = NULL;
+out:
+        return ret;
+}
+
+static int of_destroy_spu(struct spu *spu)
+{
+        spu_unmap(spu);
+        of_node_put(spu_get_pdata(spu)->devnode);
+        kfree(spu->pdata);
+        spu->pdata = NULL;
+        return 0;
+}
+
+const struct spu_management_ops spu_management_of_ops = {
+        .enumerate_spus = of_enumerate_spus,
+        .create_spu = of_create_spu,
+        .destroy_spu = of_destroy_spu,
+};
 
 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);
+        old_mask = in_be64(&spu_get_pdata(spu)->priv1->int_mask_RW[class]);
+        out_be64(&spu_get_pdata(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);
+        old_mask = in_be64(&spu_get_pdata(spu)->priv1->int_mask_RW[class]);
+        out_be64(&spu_get_pdata(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);
+        out_be64(&spu_get_pdata(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]);
+        return in_be64(&spu_get_pdata(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);
+        out_be64(&spu_get_pdata(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]);
+        return in_be64(&spu_get_pdata(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);
+        out_be64(&spu_get_pdata(spu)->priv1->int_route_RW, route);
 }
 
 static u64 mfc_dar_get(struct spu *spu)
 {
-        return in_be64(&spu->priv1->mfc_dar_RW);
+        return in_be64(&spu_get_pdata(spu)->priv1->mfc_dar_RW);
 }
 
 static u64 mfc_dsisr_get(struct spu *spu)
 {
-        return in_be64(&spu->priv1->mfc_dsisr_RW);
+        return in_be64(&spu_get_pdata(spu)->priv1->mfc_dsisr_RW);
 }
 
 static void mfc_dsisr_set(struct spu *spu, u64 dsisr)
 {
-        out_be64(&spu->priv1->mfc_dsisr_RW, dsisr);
+        out_be64(&spu_get_pdata(spu)->priv1->mfc_dsisr_RW, dsisr);
 }
 
-static void mfc_sdr_set(struct spu *spu, u64 sdr)
+static void mfc_sdr_setup(struct spu *spu)
 {
-        out_be64(&spu->priv1->mfc_sdr_RW, sdr);
+        out_be64(&spu_get_pdata(spu)->priv1->mfc_sdr_RW, mfspr(SPRN_SDR1));
 }
 
 static void mfc_sr1_set(struct spu *spu, u64 sr1)
 {
-        out_be64(&spu->priv1->mfc_sr1_RW, sr1);
+        out_be64(&spu_get_pdata(spu)->priv1->mfc_sr1_RW, sr1);
 }
 
 static u64 mfc_sr1_get(struct spu *spu)
 {
-        return in_be64(&spu->priv1->mfc_sr1_RW);
+        return in_be64(&spu_get_pdata(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);
+        out_be64(&spu_get_pdata(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);
+        return in_be64(&spu_get_pdata(spu)->priv1->mfc_tclass_id_RW);
 }
 
 static void tlb_invalidate(struct spu *spu)
 {
-        out_be64(&spu->priv1->tlb_invalidate_entry_W, 0ul);
+        out_be64(&spu_get_pdata(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);
+        out_be64(&spu_get_pdata(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);
+        return in_be64(
+                &spu_get_pdata(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);
+        out_be64(&spu_get_pdata(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);
+        return in_be64(
+                &spu_get_pdata(spu)->priv1->resource_allocation_enable_RW);
 }
 
 const struct spu_priv1_ops spu_priv1_mmio_ops =
@@ -146,7 +535,7 @@ const struct spu_priv1_ops spu_priv1_mmio_ops =
         .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_sdr_setup = mfc_sdr_setup,
         .mfc_sr1_set = mfc_sr1_set,
         .mfc_sr1_get = mfc_sr1_get,
         .mfc_tclass_id_set = mfc_tclass_id_set,
diff --git a/arch/powerpc/platforms/cell/spu_priv1_mmio.h b/arch/powerpc/platforms/cell/spu_priv1_mmio.h
new file mode 100644
index 000000000000..7b62bd1cc256
--- /dev/null
+++ b/arch/powerpc/platforms/cell/spu_priv1_mmio.h
@@ -0,0 +1,26 @@
+/*
+ * spu hypervisor abstraction for direct hardware access.
+ *
+ *  Copyright (C) 2006 Sony Computer Entertainment Inc.
+ *  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
+ */
+
+#ifndef SPU_PRIV1_MMIO_H
+#define SPU_PRIV1_MMIO_H
+
+struct device_node *spu_devnode(struct spu *spu);
+
+#endif /* SPU_PRIV1_MMIO_H */
diff --git a/arch/powerpc/platforms/cell/spufs/Makefile b/arch/powerpc/platforms/cell/spufs/Makefile
index ecdfbb35f82e..472217d19faf 100644
--- a/arch/powerpc/platforms/cell/spufs/Makefile
+++ b/arch/powerpc/platforms/cell/spufs/Makefile
@@ -1,7 +1,7 @@
 obj-y += switch.o
 
 obj-$(CONFIG_SPU_FS) += spufs.o
-spufs-y += inode.o file.o context.o syscalls.o
+spufs-y += inode.o file.o context.o syscalls.o coredump.o
 spufs-y += sched.o backing_ops.o hw_ops.o run.o gang.o
 
 # Rules to build switch.o with the help of SPU tool chain
diff --git a/arch/powerpc/platforms/cell/spufs/backing_ops.c b/arch/powerpc/platforms/cell/spufs/backing_ops.c
index 2d22cd59d6fc..1898f0d3a8b8 100644
--- a/arch/powerpc/platforms/cell/spufs/backing_ops.c
+++ b/arch/powerpc/platforms/cell/spufs/backing_ops.c
@@ -36,6 +36,7 @@
 #include <asm/io.h>
 #include <asm/spu.h>
 #include <asm/spu_csa.h>
+#include <asm/spu_info.h>
 #include <asm/mmu_context.h>
 #include "spufs.h"
 
@@ -267,6 +268,11 @@ static char *spu_backing_get_ls(struct spu_context *ctx)
         return ctx->csa.lscsa->ls;
 }
 
+static u32 spu_backing_runcntl_read(struct spu_context *ctx)
+{
+        return ctx->csa.prob.spu_runcntl_RW;
+}
+
 static void spu_backing_runcntl_write(struct spu_context *ctx, u32 val)
 {
         spin_lock(&ctx->csa.register_lock);
@@ -279,9 +285,26 @@ static void spu_backing_runcntl_write(struct spu_context *ctx, u32 val)
         spin_unlock(&ctx->csa.register_lock);
 }
 
-static void spu_backing_runcntl_stop(struct spu_context *ctx)
+static void spu_backing_master_start(struct spu_context *ctx)
+{
+        struct spu_state *csa = &ctx->csa;
+        u64 sr1;
+
+        spin_lock(&csa->register_lock);
+        sr1 = csa->priv1.mfc_sr1_RW | MFC_STATE1_MASTER_RUN_CONTROL_MASK;
+        csa->priv1.mfc_sr1_RW = sr1;
+        spin_unlock(&csa->register_lock);
+}
+
+static void spu_backing_master_stop(struct spu_context *ctx)
 {
-        spu_backing_runcntl_write(ctx, SPU_RUNCNTL_STOP);
+        struct spu_state *csa = &ctx->csa;
+        u64 sr1;
+
+        spin_lock(&csa->register_lock);
+        sr1 = csa->priv1.mfc_sr1_RW & ~MFC_STATE1_MASTER_RUN_CONTROL_MASK;
+        csa->priv1.mfc_sr1_RW = sr1;
+        spin_unlock(&csa->register_lock);
 }
 
 static int spu_backing_set_mfc_query(struct spu_context * ctx, u32 mask,
@@ -345,8 +368,10 @@ struct spu_context_ops spu_backing_ops = {
         .npc_write = spu_backing_npc_write,
         .status_read = spu_backing_status_read,
         .get_ls = spu_backing_get_ls,
+        .runcntl_read = spu_backing_runcntl_read,
         .runcntl_write = spu_backing_runcntl_write,
-        .runcntl_stop = spu_backing_runcntl_stop,
+        .master_start = spu_backing_master_start,
+        .master_stop = spu_backing_master_stop,
         .set_mfc_query = spu_backing_set_mfc_query,
         .read_mfc_tagstatus = spu_backing_read_mfc_tagstatus,
         .get_mfc_free_elements = spu_backing_get_mfc_free_elements,
diff --git a/arch/powerpc/platforms/cell/spufs/context.c b/arch/powerpc/platforms/cell/spufs/context.c
index 034cf6af53a2..0870009f56db 100644
--- a/arch/powerpc/platforms/cell/spufs/context.c
+++ b/arch/powerpc/platforms/cell/spufs/context.c
@@ -120,6 +120,33 @@ void spu_unmap_mappings(struct spu_context *ctx)
                 unmap_mapping_range(ctx->signal2, 0, 0x4000, 1);
 }
 
+int spu_acquire_exclusive(struct spu_context *ctx)
+{
+        int ret = 0;
+
+        down_write(&ctx->state_sema);
+        /* ctx is about to be freed, can't acquire any more */
+        if (!ctx->owner) {
+                ret = -EINVAL;
+                goto out;
+        }
+
+        if (ctx->state == SPU_STATE_SAVED) {
+                ret = spu_activate(ctx, 0);
+                if (ret)
+                        goto out;
+                ctx->state = SPU_STATE_RUNNABLE;
+        } else {
+                /* We need to exclude userspace access to the context. */
+                spu_unmap_mappings(ctx);
+        }
+
+out:
+        if (ret)
+                up_write(&ctx->state_sema);
+        return ret;
+}
+
 int spu_acquire_runnable(struct spu_context *ctx)
 {
         int ret = 0;
diff --git a/arch/powerpc/platforms/cell/spufs/coredump.c b/arch/powerpc/platforms/cell/spufs/coredump.c
new file mode 100644
index 000000000000..725e19561159
--- /dev/null
+++ b/arch/powerpc/platforms/cell/spufs/coredump.c
@@ -0,0 +1,238 @@
+/*
+ * SPU core dump code
+ *
+ * (C) Copyright 2006 IBM Corp.
+ *
+ * Author: Dwayne Grant McConnell <decimal@us.ibm.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <linux/elf.h>
+#include <linux/file.h>
+#include <linux/fs.h>
+#include <linux/list.h>
+#include <linux/module.h>
+#include <linux/syscalls.h>
+
+#include <asm/uaccess.h>
+
+#include "spufs.h"
+
+struct spufs_ctx_info {
+        struct list_head list;
+        int dfd;
+        int memsize; /* in bytes */
+        struct spu_context *ctx;
+};
+
+static LIST_HEAD(ctx_info_list);
+
+static ssize_t do_coredump_read(int num, struct spu_context *ctx, void __user *buffer,
+                                size_t size, loff_t *off)
+{
+        u64 data;
+        int ret;
+
+        if (spufs_coredump_read[num].read)
+                return spufs_coredump_read[num].read(ctx, buffer, size, off);
+
+        data = spufs_coredump_read[num].get(ctx);
+        ret = copy_to_user(buffer, &data, 8);
+        return ret ? -EFAULT : 8;
+}
+
+/*
+ * These are the only things you should do on a core-file: use only these
+ * functions to write out all the necessary info.
+ */
+static int spufs_dump_write(struct file *file, const void *addr, int nr)
+{
+        return file->f_op->write(file, addr, nr, &file->f_pos) == nr;
+}
+
+static int spufs_dump_seek(struct file *file, loff_t off)
+{
+        if (file->f_op->llseek) {
+                if (file->f_op->llseek(file, off, 0) != off)
+                        return 0;
+        } else
+                file->f_pos = off;
+        return 1;
+}
+
+static void spufs_fill_memsize(struct spufs_ctx_info *ctx_info)
+{
+        struct spu_context *ctx;
+        unsigned long long lslr;
+
+        ctx = ctx_info->ctx;
+        lslr = ctx->csa.priv2.spu_lslr_RW;
+        ctx_info->memsize = lslr + 1;
+}
+
+static int spufs_ctx_note_size(struct spufs_ctx_info *ctx_info)
+{
+        int dfd, memsize, i, sz, total = 0;
+        char *name;
+        char fullname[80];
+
+        dfd = ctx_info->dfd;
+        memsize = ctx_info->memsize;
+
+        for (i = 0; spufs_coredump_read[i].name; i++) {
+                name = spufs_coredump_read[i].name;
+                sz = spufs_coredump_read[i].size;
+
+                sprintf(fullname, "SPU/%d/%s", dfd, name);
+
+                total += sizeof(struct elf_note);
+                total += roundup(strlen(fullname) + 1, 4);
+                if (!strcmp(name, "mem"))
+                        total += roundup(memsize, 4);
+                else
+                        total += roundup(sz, 4);
+        }
+
+        return total;
+}
+
+static int spufs_add_one_context(struct file *file, int dfd)
+{
+        struct spu_context *ctx;
+        struct spufs_ctx_info *ctx_info;
+        int size;
+
+        ctx = SPUFS_I(file->f_dentry->d_inode)->i_ctx;
+        if (ctx->flags & SPU_CREATE_NOSCHED)
+                return 0;
+
+        ctx_info = kzalloc(sizeof(*ctx_info), GFP_KERNEL);
+        if (unlikely(!ctx_info))
+                return -ENOMEM;
+
+        ctx_info->dfd = dfd;
+        ctx_info->ctx = ctx;
+
+        spufs_fill_memsize(ctx_info);
+
+        size = spufs_ctx_note_size(ctx_info);
+        list_add(&ctx_info->list, &ctx_info_list);
+        return size;
+}
+
+/*
+ * The additional architecture-specific notes for Cell are various
+ * context files in the spu context.
+ *
+ * This function iterates over all open file descriptors and sees
+ * if they are a directory in spufs.  In that case we use spufs
+ * internal functionality to dump them without needing to actually
+ * open the files.
+ */
+static int spufs_arch_notes_size(void)
+{
+        struct fdtable *fdt = files_fdtable(current->files);
+        int size = 0, fd;
+
+        for (fd = 0; fd < fdt->max_fds; fd++) {
+                if (FD_ISSET(fd, fdt->open_fds)) {
+                        struct file *file = fcheck(fd);
+
+                        if (file && file->f_op == &spufs_context_fops) {
+                                int rval = spufs_add_one_context(file, fd);
+                                if (rval < 0)
+                                        break;
+                                size += rval;
+                        }
+                }
+        }
+
+        return size;
+}
+
+static void spufs_arch_write_note(struct spufs_ctx_info *ctx_info, int i,
+                                struct file *file)
+{
+        struct spu_context *ctx;
+        loff_t pos = 0;
+        int sz, dfd, rc, total = 0;
+        const int bufsz = 4096;
+        char *name;
+        char fullname[80], *buf;
+        struct elf_note en;
+
+        buf = kmalloc(bufsz, GFP_KERNEL);
+        if (!buf)
+                return;
+
+        dfd = ctx_info->dfd;
+        name = spufs_coredump_read[i].name;
+
+        if (!strcmp(name, "mem"))
+                sz = ctx_info->memsize;
+        else
+                sz = spufs_coredump_read[i].size;
+
+        ctx = ctx_info->ctx;
+        if (!ctx) {
+                return;
+        }
+
+        sprintf(fullname, "SPU/%d/%s", dfd, name);
+        en.n_namesz = strlen(fullname) + 1;
+        en.n_descsz = sz;
+        en.n_type = NT_SPU;
+
+        if (!spufs_dump_write(file, &en, sizeof(en)))
+                return;
+        if (!spufs_dump_write(file, fullname, en.n_namesz))
+                return;
+        if (!spufs_dump_seek(file, roundup((unsigned long)file->f_pos, 4)))
+                return;
+
+        do {
+                rc = do_coredump_read(i, ctx, buf, bufsz, &pos);
+                if (rc > 0) {
+                        if (!spufs_dump_write(file, buf, rc))
+                                return;
+                        total += rc;
+                }
+        } while (rc == bufsz && total < sz);
+
+        spufs_dump_seek(file, roundup((unsigned long)file->f_pos
+                                                - total + sz, 4));
+}
+
+static void spufs_arch_write_notes(struct file *file)
+{
+        int j;
+        struct spufs_ctx_info *ctx_info, *next;
+
+        list_for_each_entry_safe(ctx_info, next, &ctx_info_list, list) {
+                spu_acquire_saved(ctx_info->ctx);
+                for (j = 0; j < spufs_coredump_num_notes; j++)
+                        spufs_arch_write_note(ctx_info, j, file);
+                spu_release(ctx_info->ctx);
+                list_del(&ctx_info->list);
+                kfree(ctx_info);
+        }
+}
+
+struct spu_coredump_calls spufs_coredump_calls = {
+        .arch_notes_size = spufs_arch_notes_size,
+        .arch_write_notes = spufs_arch_write_notes,
+        .owner = THIS_MODULE,
+};
diff --git a/arch/powerpc/platforms/cell/spufs/file.c b/arch/powerpc/platforms/cell/spufs/file.c
index 533e2723e184..347eff56fcbd 100644
--- a/arch/powerpc/platforms/cell/spufs/file.c
+++ b/arch/powerpc/platforms/cell/spufs/file.c
@@ -32,13 +32,13 @@
 #include <asm/io.h>
 #include <asm/semaphore.h>
 #include <asm/spu.h>
+#include <asm/spu_info.h>
 #include <asm/uaccess.h>
 
 #include "spufs.h"
 
 #define SPUFS_MMAP_4K (PAGE_SIZE == 0x1000)
 
-
 static int
 spufs_mem_open(struct inode *inode, struct file *file)
 {
@@ -51,18 +51,23 @@ spufs_mem_open(struct inode *inode, struct file *file)
 }
 
 static ssize_t
+__spufs_mem_read(struct spu_context *ctx, char __user *buffer,
+                        size_t size, loff_t *pos)
+{
+        char *local_store = ctx->ops->get_ls(ctx);
+        return simple_read_from_buffer(buffer, size, pos, local_store,
+                                        LS_SIZE);
+}
+
+static ssize_t
 spufs_mem_read(struct file *file, char __user *buffer,
                                 size_t size, loff_t *pos)
 {
-        struct spu_context *ctx = file->private_data;
-        char *local_store;
         int ret;
+        struct spu_context *ctx = file->private_data;
 
         spu_acquire(ctx);
-
-        local_store = ctx->ops->get_ls(ctx);
-        ret = simple_read_from_buffer(buffer, size, pos, local_store, LS_SIZE);
-
+        ret = __spufs_mem_read(ctx, buffer, size, pos);
         spu_release(ctx);
         return ret;
 }
@@ -104,11 +109,11 @@ spufs_mem_mmap_nopage(struct vm_area_struct *vma,
 
         if (ctx->state == SPU_STATE_SAVED) {
                 vma->vm_page_prot = __pgprot(pgprot_val(vma->vm_page_prot)
-                                        & ~(_PAGE_NO_CACHE | _PAGE_GUARDED));
+                                                        & ~_PAGE_NO_CACHE);
                 page = vmalloc_to_page(ctx->csa.lscsa->ls + offset);
         } else {
                 vma->vm_page_prot = __pgprot(pgprot_val(vma->vm_page_prot)
-                                        | _PAGE_NO_CACHE | _PAGE_GUARDED);
+                                                        | _PAGE_NO_CACHE);
                 page = pfn_to_page((ctx->spu->local_store_phys + offset)
                                    >> PAGE_SHIFT);
         }
@@ -131,7 +136,7 @@ spufs_mem_mmap(struct file *file, struct vm_area_struct *vma)
         if (!(vma->vm_flags & VM_SHARED))
                 return -EINVAL;
 
-        /* FIXME: */
+        vma->vm_flags |= VM_IO;
         vma->vm_page_prot = __pgprot(pgprot_val(vma->vm_page_prot)
                                      | _PAGE_NO_CACHE);
 
@@ -200,7 +205,7 @@ static int spufs_cntl_mmap(struct file *file, struct vm_area_struct *vma)
         if (!(vma->vm_flags & VM_SHARED))
                 return -EINVAL;
 
-        vma->vm_flags |= VM_RESERVED;
+        vma->vm_flags |= VM_IO;
         vma->vm_page_prot = __pgprot(pgprot_val(vma->vm_page_prot)
                                      | _PAGE_NO_CACHE | _PAGE_GUARDED);
 
@@ -261,18 +266,23 @@ spufs_regs_open(struct inode *inode, struct file *file)
 }
 
 static ssize_t
+__spufs_regs_read(struct spu_context *ctx, char __user *buffer,
+                        size_t size, loff_t *pos)
+{
+        struct spu_lscsa *lscsa = ctx->csa.lscsa;
+        return simple_read_from_buffer(buffer, size, pos,
+                                      lscsa->gprs, sizeof lscsa->gprs);
+}
+
+static ssize_t
 spufs_regs_read(struct file *file, char __user *buffer,
                 size_t size, loff_t *pos)
 {
-        struct spu_context *ctx = file->private_data;
-        struct spu_lscsa *lscsa = ctx->csa.lscsa;
         int ret;
+        struct spu_context *ctx = file->private_data;
 
         spu_acquire_saved(ctx);
-
-        ret = simple_read_from_buffer(buffer, size, pos,
-                                      lscsa->gprs, sizeof lscsa->gprs);
-
+        ret = __spufs_regs_read(ctx, buffer, size, pos);
         spu_release(ctx);
         return ret;
 }
@@ -307,18 +317,23 @@ static struct file_operations spufs_regs_fops = {
 };
 
 static ssize_t
+__spufs_fpcr_read(struct spu_context *ctx, char __user * buffer,
+                        size_t size, loff_t * pos)
+{
+        struct spu_lscsa *lscsa = ctx->csa.lscsa;
+        return simple_read_from_buffer(buffer, size, pos,
+                                      &lscsa->fpcr, sizeof(lscsa->fpcr));
+}
+
+static ssize_t
 spufs_fpcr_read(struct file *file, char __user * buffer,
                 size_t size, loff_t * pos)
 {
-        struct spu_context *ctx = file->private_data;
-        struct spu_lscsa *lscsa = ctx->csa.lscsa;
         int ret;
+        struct spu_context *ctx = file->private_data;
 
         spu_acquire_saved(ctx);
-
-        ret = simple_read_from_buffer(buffer, size, pos,
-                                      &lscsa->fpcr, sizeof(lscsa->fpcr));
-
+        ret = __spufs_fpcr_read(ctx, buffer, size, pos);
         spu_release(ctx);
         return ret;
 }
@@ -718,23 +733,41 @@ static int spufs_signal1_open(struct inode *inode, struct file *file)
         return nonseekable_open(inode, file);
 }
 
-static ssize_t spufs_signal1_read(struct file *file, char __user *buf,
+static ssize_t __spufs_signal1_read(struct spu_context *ctx, char __user *buf,
                         size_t len, loff_t *pos)
 {
-        struct spu_context *ctx = file->private_data;
+        int ret = 0;
         u32 data;
 
         if (len < 4)
                 return -EINVAL;
 
-        spu_acquire(ctx);
-        data = ctx->ops->signal1_read(ctx);
-        spu_release(ctx);
+        if (ctx->csa.spu_chnlcnt_RW[3]) {
+                data = ctx->csa.spu_chnldata_RW[3];
+                ret = 4;
+        }
+
+        if (!ret)
+                goto out;
 
         if (copy_to_user(buf, &data, 4))
                 return -EFAULT;
 
-        return 4;
+out:
+        return ret;
+}
+
+static ssize_t spufs_signal1_read(struct file *file, char __user *buf,
+                        size_t len, loff_t *pos)
+{
+        int ret;
+        struct spu_context *ctx = file->private_data;
+
+        spu_acquire_saved(ctx);
+        ret = __spufs_signal1_read(ctx, buf, len, pos);
+        spu_release(ctx);
+
+        return ret;
 }
 
 static ssize_t spufs_signal1_write(struct file *file, const char __user *buf,
@@ -782,7 +815,7 @@ static int spufs_signal1_mmap(struct file *file, struct vm_area_struct *vma)
         if (!(vma->vm_flags & VM_SHARED))
                 return -EINVAL;
 
-        vma->vm_flags |= VM_RESERVED;
+        vma->vm_flags |= VM_IO;
         vma->vm_page_prot = __pgprot(pgprot_val(vma->vm_page_prot)
                                      | _PAGE_NO_CACHE | _PAGE_GUARDED);
 
@@ -807,25 +840,41 @@ static int spufs_signal2_open(struct inode *inode, struct file *file)
         return nonseekable_open(inode, file);
 }
 
-static ssize_t spufs_signal2_read(struct file *file, char __user *buf,
+static ssize_t __spufs_signal2_read(struct spu_context *ctx, char __user *buf,
                         size_t len, loff_t *pos)
 {
-        struct spu_context *ctx;
+        int ret = 0;
         u32 data;
 
-        ctx = file->private_data;
-
         if (len < 4)
                 return -EINVAL;
 
-        spu_acquire(ctx);
-        data = ctx->ops->signal2_read(ctx);
-        spu_release(ctx);
+        if (ctx->csa.spu_chnlcnt_RW[4]) {
+                data =  ctx->csa.spu_chnldata_RW[4];
+                ret = 4;
+        }
+
+        if (!ret)
+                goto out;
 
         if (copy_to_user(buf, &data, 4))
                 return -EFAULT;
 
-        return 4;
+out:
+        return ret;
+}
+
+static ssize_t spufs_signal2_read(struct file *file, char __user *buf,
+                        size_t len, loff_t *pos)
+{
+        struct spu_context *ctx = file->private_data;
+        int ret;
+
+        spu_acquire_saved(ctx);
+        ret = __spufs_signal2_read(ctx, buf, len, pos);
+        spu_release(ctx);
+
+        return ret;
 }
 
 static ssize_t spufs_signal2_write(struct file *file, const char __user *buf,
@@ -874,8 +923,7 @@ static int spufs_signal2_mmap(struct file *file, struct vm_area_struct *vma)
         if (!(vma->vm_flags & VM_SHARED))
                 return -EINVAL;
 
-        /* FIXME: */
-        vma->vm_flags |= VM_RESERVED;
+        vma->vm_flags |= VM_IO;
         vma->vm_page_prot = __pgprot(pgprot_val(vma->vm_page_prot)
                                      | _PAGE_NO_CACHE | _PAGE_GUARDED);
 
@@ -902,13 +950,19 @@ static void spufs_signal1_type_set(void *data, u64 val)
         spu_release(ctx);
 }
 
+static u64 __spufs_signal1_type_get(void *data)
+{
+        struct spu_context *ctx = data;
+        return ctx->ops->signal1_type_get(ctx);
+}
+
 static u64 spufs_signal1_type_get(void *data)
 {
         struct spu_context *ctx = data;
         u64 ret;
 
         spu_acquire(ctx);
-        ret = ctx->ops->signal1_type_get(ctx);
+        ret = __spufs_signal1_type_get(data);
         spu_release(ctx);
 
         return ret;
@@ -925,13 +979,19 @@ static void spufs_signal2_type_set(void *data, u64 val)
         spu_release(ctx);
 }
 
+static u64 __spufs_signal2_type_get(void *data)
+{
+        struct spu_context *ctx = data;
+        return ctx->ops->signal2_type_get(ctx);
+}
+
 static u64 spufs_signal2_type_get(void *data)
 {
         struct spu_context *ctx = data;
         u64 ret;
 
         spu_acquire(ctx);
-        ret = ctx->ops->signal2_type_get(ctx);
+        ret = __spufs_signal2_type_get(data);
         spu_release(ctx);
 
         return ret;
@@ -958,7 +1018,7 @@ static int spufs_mss_mmap(struct file *file, struct vm_area_struct *vma)
         if (!(vma->vm_flags & VM_SHARED))
                 return -EINVAL;
 
-        vma->vm_flags |= VM_RESERVED;
+        vma->vm_flags |= VM_IO;
         vma->vm_page_prot = __pgprot(pgprot_val(vma->vm_page_prot)
                                      | _PAGE_NO_CACHE | _PAGE_GUARDED);
 
@@ -1000,7 +1060,7 @@ static int spufs_psmap_mmap(struct file *file, struct vm_area_struct *vma)
         if (!(vma->vm_flags & VM_SHARED))
                 return -EINVAL;
 
-        vma->vm_flags |= VM_RESERVED;
+        vma->vm_flags |= VM_IO;
         vma->vm_page_prot = __pgprot(pgprot_val(vma->vm_page_prot)
                                      | _PAGE_NO_CACHE | _PAGE_GUARDED);
 
@@ -1041,7 +1101,7 @@ static int spufs_mfc_mmap(struct file *file, struct vm_area_struct *vma)
         if (!(vma->vm_flags & VM_SHARED))
                 return -EINVAL;
 
-        vma->vm_flags |= VM_RESERVED;
+        vma->vm_flags |= VM_IO;
         vma->vm_page_prot = __pgprot(pgprot_val(vma->vm_page_prot)
                                      | _PAGE_NO_CACHE | _PAGE_GUARDED);
 
@@ -1265,6 +1325,7 @@ static ssize_t spufs_mfc_write(struct file *file, const char __user *buffer,
                 goto out;
 
         ctx->tagwait |= 1 << cmd.tag;
+        ret = size;
 
 out:
         return ret;
@@ -1360,7 +1421,8 @@ static u64 spufs_npc_get(void *data)
         spu_release(ctx);
         return ret;
 }
-DEFINE_SIMPLE_ATTRIBUTE(spufs_npc_ops, spufs_npc_get, spufs_npc_set, "%llx\n")
+DEFINE_SIMPLE_ATTRIBUTE(spufs_npc_ops, spufs_npc_get, spufs_npc_set,
+                        "0x%llx\n")
 
 static void spufs_decr_set(void *data, u64 val)
 {
@@ -1371,18 +1433,24 @@ static void spufs_decr_set(void *data, u64 val)
         spu_release(ctx);
 }
 
-static u64 spufs_decr_get(void *data)
+static u64 __spufs_decr_get(void *data)
 {
         struct spu_context *ctx = data;
         struct spu_lscsa *lscsa = ctx->csa.lscsa;
+        return lscsa->decr.slot[0];
+}
+
+static u64 spufs_decr_get(void *data)
+{
+        struct spu_context *ctx = data;
         u64 ret;
         spu_acquire_saved(ctx);
-        ret = lscsa->decr.slot[0];
+        ret = __spufs_decr_get(data);
         spu_release(ctx);
         return ret;
 }
 DEFINE_SIMPLE_ATTRIBUTE(spufs_decr_ops, spufs_decr_get, spufs_decr_set,
-                        "%llx\n")
+                        "0x%llx\n")
 
 static void spufs_decr_status_set(void *data, u64 val)
 {
@@ -1393,62 +1461,76 @@ static void spufs_decr_status_set(void *data, u64 val)
         spu_release(ctx);
 }
 
-static u64 spufs_decr_status_get(void *data)
+static u64 __spufs_decr_status_get(void *data)
 {
         struct spu_context *ctx = data;
         struct spu_lscsa *lscsa = ctx->csa.lscsa;
+        return lscsa->decr_status.slot[0];
+}
+
+static u64 spufs_decr_status_get(void *data)
+{
+        struct spu_context *ctx = data;
         u64 ret;
         spu_acquire_saved(ctx);
-        ret = lscsa->decr_status.slot[0];
+        ret = __spufs_decr_status_get(data);
         spu_release(ctx);
         return ret;
 }
 DEFINE_SIMPLE_ATTRIBUTE(spufs_decr_status_ops, spufs_decr_status_get,
-                        spufs_decr_status_set, "%llx\n")
+                        spufs_decr_status_set, "0x%llx\n")
 
-static void spufs_spu_tag_mask_set(void *data, u64 val)
+static void spufs_event_mask_set(void *data, u64 val)
 {
         struct spu_context *ctx = data;
         struct spu_lscsa *lscsa = ctx->csa.lscsa;
         spu_acquire_saved(ctx);
-        lscsa->tag_mask.slot[0] = (u32) val;
+        lscsa->event_mask.slot[0] = (u32) val;
         spu_release(ctx);
 }
 
-static u64 spufs_spu_tag_mask_get(void *data)
+static u64 __spufs_event_mask_get(void *data)
 {
         struct spu_context *ctx = data;
         struct spu_lscsa *lscsa = ctx->csa.lscsa;
+        return lscsa->event_mask.slot[0];
+}
+
+static u64 spufs_event_mask_get(void *data)
+{
+        struct spu_context *ctx = data;
         u64 ret;
         spu_acquire_saved(ctx);
-        ret = lscsa->tag_mask.slot[0];
+        ret = __spufs_event_mask_get(data);
         spu_release(ctx);
         return ret;
 }
-DEFINE_SIMPLE_ATTRIBUTE(spufs_spu_tag_mask_ops, spufs_spu_tag_mask_get,
-                        spufs_spu_tag_mask_set, "%llx\n")
+DEFINE_SIMPLE_ATTRIBUTE(spufs_event_mask_ops, spufs_event_mask_get,
+                        spufs_event_mask_set, "0x%llx\n")
 
-static void spufs_event_mask_set(void *data, u64 val)
+static u64 __spufs_event_status_get(void *data)
 {
         struct spu_context *ctx = data;
-        struct spu_lscsa *lscsa = ctx->csa.lscsa;
-        spu_acquire_saved(ctx);
-        lscsa->event_mask.slot[0] = (u32) val;
-        spu_release(ctx);
+        struct spu_state *state = &ctx->csa;
+        u64 stat;
+        stat = state->spu_chnlcnt_RW[0];
+        if (stat)
+                return state->spu_chnldata_RW[0];
+        return 0;
 }
 
-static u64 spufs_event_mask_get(void *data)
+static u64 spufs_event_status_get(void *data)
 {
         struct spu_context *ctx = data;
-        struct spu_lscsa *lscsa = ctx->csa.lscsa;
-        u64 ret;
+        u64 ret = 0;
+
         spu_acquire_saved(ctx);
-        ret = lscsa->event_mask.slot[0];
+        ret = __spufs_event_status_get(data);
         spu_release(ctx);
         return ret;
 }
-DEFINE_SIMPLE_ATTRIBUTE(spufs_event_mask_ops, spufs_event_mask_get,
-                        spufs_event_mask_set, "%llx\n")
+DEFINE_SIMPLE_ATTRIBUTE(spufs_event_status_ops, spufs_event_status_get,
+                        NULL, "0x%llx\n")
 
 static void spufs_srr0_set(void *data, u64 val)
 {
@@ -1470,7 +1552,7 @@ static u64 spufs_srr0_get(void *data)
         return ret;
 }
 DEFINE_SIMPLE_ATTRIBUTE(spufs_srr0_ops, spufs_srr0_get, spufs_srr0_set,
-                        "%llx\n")
+                        "0x%llx\n")
 
 static u64 spufs_id_get(void *data)
 {
@@ -1488,12 +1570,18 @@ static u64 spufs_id_get(void *data)
 }
 DEFINE_SIMPLE_ATTRIBUTE(spufs_id_ops, spufs_id_get, NULL, "0x%llx\n")
 
-static u64 spufs_object_id_get(void *data)
+static u64 __spufs_object_id_get(void *data)
 {
         struct spu_context *ctx = data;
         return ctx->object_id;
 }
 
+static u64 spufs_object_id_get(void *data)
+{
+        /* FIXME: Should there really be no locking here? */
+        return __spufs_object_id_get(data);
+}
+
 static void spufs_object_id_set(void *data, u64 id)
 {
         struct spu_context *ctx = data;
@@ -1503,6 +1591,250 @@ static void spufs_object_id_set(void *data, u64 id)
 DEFINE_SIMPLE_ATTRIBUTE(spufs_object_id_ops, spufs_object_id_get,
                 spufs_object_id_set, "0x%llx\n");
 
+static u64 __spufs_lslr_get(void *data)
+{
+        struct spu_context *ctx = data;
+        return ctx->csa.priv2.spu_lslr_RW;
+}
+
+static u64 spufs_lslr_get(void *data)
+{
+        struct spu_context *ctx = data;
+        u64 ret;
+
+        spu_acquire_saved(ctx);
+        ret = __spufs_lslr_get(data);
+        spu_release(ctx);
+
+        return ret;
+}
+DEFINE_SIMPLE_ATTRIBUTE(spufs_lslr_ops, spufs_lslr_get, NULL, "0x%llx\n")
+
+static int spufs_info_open(struct inode *inode, struct file *file)
+{
+        struct spufs_inode_info *i = SPUFS_I(inode);
+        struct spu_context *ctx = i->i_ctx;
+        file->private_data = ctx;
+        return 0;
+}
+
+static ssize_t __spufs_mbox_info_read(struct spu_context *ctx,
+                        char __user *buf, size_t len, loff_t *pos)
+{
+        u32 mbox_stat;
+        u32 data;
+
+        mbox_stat = ctx->csa.prob.mb_stat_R;
+        if (mbox_stat & 0x0000ff) {
+                data = ctx->csa.prob.pu_mb_R;
+        }
+
+        return simple_read_from_buffer(buf, len, pos, &data, sizeof data);
+}
+
+static ssize_t spufs_mbox_info_read(struct file *file, char __user *buf,
+                                   size_t len, loff_t *pos)
+{
+        int ret;
+        struct spu_context *ctx = file->private_data;
+
+        if (!access_ok(VERIFY_WRITE, buf, len))
+                return -EFAULT;
+
+        spu_acquire_saved(ctx);
+        spin_lock(&ctx->csa.register_lock);
+        ret = __spufs_mbox_info_read(ctx, buf, len, pos);
+        spin_unlock(&ctx->csa.register_lock);
+        spu_release(ctx);
+
+        return ret;
+}
+
+static struct file_operations spufs_mbox_info_fops = {
+        .open = spufs_info_open,
+        .read = spufs_mbox_info_read,
+        .llseek  = generic_file_llseek,
+};
+
+static ssize_t __spufs_ibox_info_read(struct spu_context *ctx,
+                                char __user *buf, size_t len, loff_t *pos)
+{
+        u32 ibox_stat;
+        u32 data;
+
+        ibox_stat = ctx->csa.prob.mb_stat_R;
+        if (ibox_stat & 0xff0000) {
+                data = ctx->csa.priv2.puint_mb_R;
+        }
+
+        return simple_read_from_buffer(buf, len, pos, &data, sizeof data);
+}
+
+static ssize_t spufs_ibox_info_read(struct file *file, char __user *buf,
+                                   size_t len, loff_t *pos)
+{
+        struct spu_context *ctx = file->private_data;
+        int ret;
+
+        if (!access_ok(VERIFY_WRITE, buf, len))
+                return -EFAULT;
+
+        spu_acquire_saved(ctx);
+        spin_lock(&ctx->csa.register_lock);
+        ret = __spufs_ibox_info_read(ctx, buf, len, pos);
+        spin_unlock(&ctx->csa.register_lock);
+        spu_release(ctx);
+
+        return ret;
+}
+
+static struct file_operations spufs_ibox_info_fops = {
+        .open = spufs_info_open,
+        .read = spufs_ibox_info_read,
+        .llseek  = generic_file_llseek,
+};
+
+static ssize_t __spufs_wbox_info_read(struct spu_context *ctx,
+                        char __user *buf, size_t len, loff_t *pos)
+{
+        int i, cnt;
+        u32 data[4];
+        u32 wbox_stat;
+
+        wbox_stat = ctx->csa.prob.mb_stat_R;
+        cnt = 4 - ((wbox_stat & 0x00ff00) >> 8);
+        for (i = 0; i < cnt; i++) {
+                data[i] = ctx->csa.spu_mailbox_data[i];
+        }
+
+        return simple_read_from_buffer(buf, len, pos, &data,
+                                cnt * sizeof(u32));
+}
+
+static ssize_t spufs_wbox_info_read(struct file *file, char __user *buf,
+                                   size_t len, loff_t *pos)
+{
+        struct spu_context *ctx = file->private_data;
+        int ret;
+
+        if (!access_ok(VERIFY_WRITE, buf, len))
+                return -EFAULT;
+
+        spu_acquire_saved(ctx);
+        spin_lock(&ctx->csa.register_lock);
+        ret = __spufs_wbox_info_read(ctx, buf, len, pos);
+        spin_unlock(&ctx->csa.register_lock);
+        spu_release(ctx);
+
+        return ret;
+}
+
+static struct file_operations spufs_wbox_info_fops = {
+        .open = spufs_info_open,
+        .read = spufs_wbox_info_read,
+        .llseek  = generic_file_llseek,
+};
+
+static ssize_t __spufs_dma_info_read(struct spu_context *ctx,
+                        char __user *buf, size_t len, loff_t *pos)
+{
+        struct spu_dma_info info;
+        struct mfc_cq_sr *qp, *spuqp;
+        int i;
+
+        info.dma_info_type = ctx->csa.priv2.spu_tag_status_query_RW;
+        info.dma_info_mask = ctx->csa.lscsa->tag_mask.slot[0];
+        info.dma_info_status = ctx->csa.spu_chnldata_RW[24];
+        info.dma_info_stall_and_notify = ctx->csa.spu_chnldata_RW[25];
+        info.dma_info_atomic_command_status = ctx->csa.spu_chnldata_RW[27];
+        for (i = 0; i < 16; i++) {
+                qp = &info.dma_info_command_data[i];
+                spuqp = &ctx->csa.priv2.spuq[i];
+
+                qp->mfc_cq_data0_RW = spuqp->mfc_cq_data0_RW;
+                qp->mfc_cq_data1_RW = spuqp->mfc_cq_data1_RW;
+                qp->mfc_cq_data2_RW = spuqp->mfc_cq_data2_RW;
+                qp->mfc_cq_data3_RW = spuqp->mfc_cq_data3_RW;
+        }
+
+        return simple_read_from_buffer(buf, len, pos, &info,
+                                sizeof info);
+}
+
+static ssize_t spufs_dma_info_read(struct file *file, char __user *buf,
+                              size_t len, loff_t *pos)
+{
+        struct spu_context *ctx = file->private_data;
+        int ret;
+
+        if (!access_ok(VERIFY_WRITE, buf, len))
+                return -EFAULT;
+
+        spu_acquire_saved(ctx);
+        spin_lock(&ctx->csa.register_lock);
+        ret = __spufs_dma_info_read(ctx, buf, len, pos);
+        spin_unlock(&ctx->csa.register_lock);
+        spu_release(ctx);
+
+        return ret;
+}
+
+static struct file_operations spufs_dma_info_fops = {
+        .open = spufs_info_open,
+        .read = spufs_dma_info_read,
+};
+
+static ssize_t __spufs_proxydma_info_read(struct spu_context *ctx,
+                        char __user *buf, size_t len, loff_t *pos)
+{
+        struct spu_proxydma_info info;
+        struct mfc_cq_sr *qp, *puqp;
+        int ret = sizeof info;
+        int i;
+
+        if (len < ret)
+                return -EINVAL;
+
+        if (!access_ok(VERIFY_WRITE, buf, len))
+                return -EFAULT;
+
+        info.proxydma_info_type = ctx->csa.prob.dma_querytype_RW;
+        info.proxydma_info_mask = ctx->csa.prob.dma_querymask_RW;
+        info.proxydma_info_status = ctx->csa.prob.dma_tagstatus_R;
+        for (i = 0; i < 8; i++) {
+                qp = &info.proxydma_info_command_data[i];
+                puqp = &ctx->csa.priv2.puq[i];
+
+                qp->mfc_cq_data0_RW = puqp->mfc_cq_data0_RW;
+                qp->mfc_cq_data1_RW = puqp->mfc_cq_data1_RW;
+                qp->mfc_cq_data2_RW = puqp->mfc_cq_data2_RW;
+                qp->mfc_cq_data3_RW = puqp->mfc_cq_data3_RW;
+        }
+
+        return simple_read_from_buffer(buf, len, pos, &info,
+                                sizeof info);
+}
+
+static ssize_t spufs_proxydma_info_read(struct file *file, char __user *buf,
+                                   size_t len, loff_t *pos)
+{
+        struct spu_context *ctx = file->private_data;
+        int ret;
+
+        spu_acquire_saved(ctx);
+        spin_lock(&ctx->csa.register_lock);
+        ret = __spufs_proxydma_info_read(ctx, buf, len, pos);
+        spin_unlock(&ctx->csa.register_lock);
+        spu_release(ctx);
+
+        return ret;
+}
+
+static struct file_operations spufs_proxydma_info_fops = {
+        .open = spufs_info_open,
+        .read = spufs_proxydma_info_read,
+};
+
 struct tree_descr spufs_dir_contents[] = {
         { "mem",  &spufs_mem_fops,  0666, },
         { "regs", &spufs_regs_fops,  0666, },
@@ -1516,18 +1848,70 @@ 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, },
         { "fpcr", &spufs_fpcr_fops, 0666, },
+        { "lslr", &spufs_lslr_ops, 0444, },
+        { "mfc", &spufs_mfc_fops, 0666, },
+        { "mss", &spufs_mss_fops, 0666, },
+        { "npc", &spufs_npc_ops, 0666, },
+        { "srr0", &spufs_srr0_ops, 0666, },
         { "decr", &spufs_decr_ops, 0666, },
         { "decr_status", &spufs_decr_status_ops, 0666, },
-        { "spu_tag_mask", &spufs_spu_tag_mask_ops, 0666, },
         { "event_mask", &spufs_event_mask_ops, 0666, },
-        { "srr0", &spufs_srr0_ops, 0666, },
+        { "event_status", &spufs_event_status_ops, 0444, },
+        { "psmap", &spufs_psmap_fops, 0666, },
+        { "phys-id", &spufs_id_ops, 0666, },
+        { "object-id", &spufs_object_id_ops, 0666, },
+        { "mbox_info", &spufs_mbox_info_fops, 0444, },
+        { "ibox_info", &spufs_ibox_info_fops, 0444, },
+        { "wbox_info", &spufs_wbox_info_fops, 0444, },
+        { "dma_info", &spufs_dma_info_fops, 0444, },
+        { "proxydma_info", &spufs_proxydma_info_fops, 0444, },
+        {},
+};
+
+struct tree_descr spufs_dir_nosched_contents[] = {
+        { "mem",  &spufs_mem_fops,  0666, },
+        { "mbox", &spufs_mbox_fops, 0444, },
+        { "ibox", &spufs_ibox_fops, 0444, },
+        { "wbox", &spufs_wbox_fops, 0222, },
+        { "mbox_stat", &spufs_mbox_stat_fops, 0444, },
+        { "ibox_stat", &spufs_ibox_stat_fops, 0444, },
+        { "wbox_stat", &spufs_wbox_stat_fops, 0444, },
+        { "signal1", &spufs_signal1_fops, 0666, },
+        { "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, },
         { "psmap", &spufs_psmap_fops, 0666, },
         { "phys-id", &spufs_id_ops, 0666, },
         { "object-id", &spufs_object_id_ops, 0666, },
         {},
 };
+
+struct spufs_coredump_reader spufs_coredump_read[] = {
+        { "regs", __spufs_regs_read, NULL, 128 * 16 },
+        { "fpcr", __spufs_fpcr_read, NULL, 16 },
+        { "lslr", NULL, __spufs_lslr_get, 11 },
+        { "decr", NULL, __spufs_decr_get, 11 },
+        { "decr_status", NULL, __spufs_decr_status_get, 11 },
+        { "mem", __spufs_mem_read, NULL, 256 * 1024, },
+        { "signal1", __spufs_signal1_read, NULL, 4 },
+        { "signal1_type", NULL, __spufs_signal1_type_get, 2 },
+        { "signal2", __spufs_signal2_read, NULL, 4 },
+        { "signal2_type", NULL, __spufs_signal2_type_get, 2 },
+        { "event_mask", NULL, __spufs_event_mask_get, 8 },
+        { "event_status", NULL, __spufs_event_status_get, 8 },
+        { "mbox_info", __spufs_mbox_info_read, NULL, 4 },
+        { "ibox_info", __spufs_ibox_info_read, NULL, 4 },
+        { "wbox_info", __spufs_wbox_info_read, NULL, 16 },
+        { "dma_info", __spufs_dma_info_read, NULL, 69 * 8 },
+        { "proxydma_info", __spufs_proxydma_info_read, NULL, 35 * 8 },
+        { "object-id", NULL, __spufs_object_id_get, 19 },
+        { },
+};
+int spufs_coredump_num_notes = ARRAY_SIZE(spufs_coredump_read) - 1;
+
diff --git a/arch/powerpc/platforms/cell/spufs/hw_ops.c b/arch/powerpc/platforms/cell/spufs/hw_ops.c
index d805ffed892d..ae42e03b8c86 100644
--- a/arch/powerpc/platforms/cell/spufs/hw_ops.c
+++ b/arch/powerpc/platforms/cell/spufs/hw_ops.c
@@ -135,21 +135,11 @@ static int spu_hw_wbox_write(struct spu_context *ctx, u32 data)
         return ret;
 }
 
-static u32 spu_hw_signal1_read(struct spu_context *ctx)
-{
-        return in_be32(&ctx->spu->problem->signal_notify1);
-}
-
 static void spu_hw_signal1_write(struct spu_context *ctx, u32 data)
 {
         out_be32(&ctx->spu->problem->signal_notify1, data);
 }
 
-static u32 spu_hw_signal2_read(struct spu_context *ctx)
-{
-        return in_be32(&ctx->spu->problem->signal_notify2);
-}
-
 static void spu_hw_signal2_write(struct spu_context *ctx, u32 data)
 {
         out_be32(&ctx->spu->problem->signal_notify2, data);
@@ -217,21 +207,42 @@ static char *spu_hw_get_ls(struct spu_context *ctx)
         return ctx->spu->local_store;
 }
 
-static void spu_hw_runcntl_write(struct spu_context *ctx, u32 val)
+static u32 spu_hw_runcntl_read(struct spu_context *ctx)
 {
-        eieio();
-        out_be32(&ctx->spu->problem->spu_runcntl_RW, val);
+        return in_be32(&ctx->spu->problem->spu_runcntl_RW);
 }
 
-static void spu_hw_runcntl_stop(struct spu_context *ctx)
+static void spu_hw_runcntl_write(struct spu_context *ctx, u32 val)
 {
         spin_lock_irq(&ctx->spu->register_lock);
-        out_be32(&ctx->spu->problem->spu_runcntl_RW, SPU_RUNCNTL_STOP);
-        while (in_be32(&ctx->spu->problem->spu_status_R) & SPU_STATUS_RUNNING)
-                cpu_relax();
+        if (val & SPU_RUNCNTL_ISOLATE)
+                out_be64(&ctx->spu->priv2->spu_privcntl_RW, 4LL);
+        out_be32(&ctx->spu->problem->spu_runcntl_RW, val);
         spin_unlock_irq(&ctx->spu->register_lock);
 }
 
+static void spu_hw_master_start(struct spu_context *ctx)
+{
+        struct spu *spu = ctx->spu;
+        u64 sr1;
+
+        spin_lock_irq(&spu->register_lock);
+        sr1 = spu_mfc_sr1_get(spu) | MFC_STATE1_MASTER_RUN_CONTROL_MASK;
+        spu_mfc_sr1_set(spu, sr1);
+        spin_unlock_irq(&spu->register_lock);
+}
+
+static void spu_hw_master_stop(struct spu_context *ctx)
+{
+        struct spu *spu = ctx->spu;
+        u64 sr1;
+
+        spin_lock_irq(&spu->register_lock);
+        sr1 = spu_mfc_sr1_get(spu) & ~MFC_STATE1_MASTER_RUN_CONTROL_MASK;
+        spu_mfc_sr1_set(spu, sr1);
+        spin_unlock_irq(&spu->register_lock);
+}
+
 static int spu_hw_set_mfc_query(struct spu_context * ctx, u32 mask, u32 mode)
 {
         struct spu_problem __iomem *prob = ctx->spu->problem;
@@ -291,9 +302,7 @@ struct spu_context_ops spu_hw_ops = {
         .mbox_stat_poll = spu_hw_mbox_stat_poll,
         .ibox_read = spu_hw_ibox_read,
         .wbox_write = spu_hw_wbox_write,
-        .signal1_read = spu_hw_signal1_read,
         .signal1_write = spu_hw_signal1_write,
-        .signal2_read = spu_hw_signal2_read,
         .signal2_write = spu_hw_signal2_write,
         .signal1_type_set = spu_hw_signal1_type_set,
         .signal1_type_get = spu_hw_signal1_type_get,
@@ -303,8 +312,10 @@ struct spu_context_ops spu_hw_ops = {
         .npc_write = spu_hw_npc_write,
         .status_read = spu_hw_status_read,
         .get_ls = spu_hw_get_ls,
+        .runcntl_read = spu_hw_runcntl_read,
         .runcntl_write = spu_hw_runcntl_write,
-        .runcntl_stop = spu_hw_runcntl_stop,
+        .master_start = spu_hw_master_start,
+        .master_stop = spu_hw_master_stop,
         .set_mfc_query = spu_hw_set_mfc_query,
         .read_mfc_tagstatus = spu_hw_read_mfc_tagstatus,
         .get_mfc_free_elements = spu_hw_get_mfc_free_elements,
diff --git a/arch/powerpc/platforms/cell/spufs/inode.c b/arch/powerpc/platforms/cell/spufs/inode.c
index 427d00a4f6a0..738b9244382f 100644
--- a/arch/powerpc/platforms/cell/spufs/inode.c
+++ b/arch/powerpc/platforms/cell/spufs/inode.c
@@ -33,21 +33,22 @@
 #include <linux/slab.h>
 #include <linux/parser.h>
 
-#include <asm/io.h>
+#include <asm/prom.h>
 #include <asm/semaphore.h>
 #include <asm/spu.h>
 #include <asm/uaccess.h>
 
 #include "spufs.h"
 
-static kmem_cache_t *spufs_inode_cache;
+static struct kmem_cache *spufs_inode_cache;
+char *isolated_loader;
 
 static struct inode *
 spufs_alloc_inode(struct super_block *sb)
 {
         struct spufs_inode_info *ei;
 
-        ei = kmem_cache_alloc(spufs_inode_cache, SLAB_KERNEL);
+        ei = kmem_cache_alloc(spufs_inode_cache, GFP_KERNEL);
         if (!ei)
                 return NULL;
 
@@ -64,7 +65,7 @@ spufs_destroy_inode(struct inode *inode)
 }
 
 static void
-spufs_init_once(void *p, kmem_cache_t * cachep, unsigned long flags)
+spufs_init_once(void *p, struct kmem_cache * cachep, unsigned long flags)
 {
         struct spufs_inode_info *ei = p;
 
@@ -204,7 +205,7 @@ static int spufs_dir_close(struct inode *inode, struct file *file)
         struct dentry *dir;
         int ret;
 
-        dir = file->f_dentry;
+        dir = file->f_path.dentry;
         parent = dir->d_parent->d_inode;
         ctx = SPUFS_I(dir->d_inode)->i_ctx;
 
@@ -231,6 +232,7 @@ struct file_operations spufs_context_fops = {
         .readdir        = dcache_readdir,
         .fsync          = simple_sync_file,
 };
+EXPORT_SYMBOL_GPL(spufs_context_fops);
 
 static int
 spufs_mkdir(struct inode *dir, struct dentry *dentry, unsigned int flags,
@@ -255,10 +257,14 @@ spufs_mkdir(struct inode *dir, struct dentry *dentry, unsigned int flags,
                 goto out_iput;
 
         ctx->flags = flags;
-
         inode->i_op = &spufs_dir_inode_operations;
         inode->i_fop = &simple_dir_operations;
-        ret = spufs_fill_dir(dentry, spufs_dir_contents, mode, ctx);
+        if (flags & SPU_CREATE_NOSCHED)
+                ret = spufs_fill_dir(dentry, spufs_dir_nosched_contents,
+                                         mode, ctx);
+        else
+                ret = spufs_fill_dir(dentry, spufs_dir_contents, mode, ctx);
+
         if (ret)
                 goto out_free_ctx;
 
@@ -307,6 +313,20 @@ static int spufs_create_context(struct inode *inode,
 {
         int ret;
 
+        ret = -EPERM;
+        if ((flags & SPU_CREATE_NOSCHED) &&
+            !capable(CAP_SYS_NICE))
+                goto out_unlock;
+
+        ret = -EINVAL;
+        if ((flags & (SPU_CREATE_NOSCHED | SPU_CREATE_ISOLATE))
+            == SPU_CREATE_ISOLATE)
+                goto out_unlock;
+
+        ret = -ENODEV;
+        if ((flags & SPU_CREATE_ISOLATE) && !isolated_loader)
+                goto out_unlock;
+
         ret = spufs_mkdir(inode, dentry, flags, mode & S_IRWXUGO);
         if (ret)
                 goto out_unlock;
@@ -343,7 +363,7 @@ static int spufs_gang_close(struct inode *inode, struct file *file)
         struct dentry *dir;
         int ret;
 
-        dir = file->f_dentry;
+        dir = file->f_path.dentry;
         parent = dir->d_parent->d_inode;
 
         ret = spufs_rmgang(parent, dir);
@@ -540,6 +560,30 @@ spufs_parse_options(char *options, struct inode *root)
         return 1;
 }
 
+static void
+spufs_init_isolated_loader(void)
+{
+        struct device_node *dn;
+        const char *loader;
+        int size;
+
+        dn = of_find_node_by_path("/spu-isolation");
+        if (!dn)
+                return;
+
+        loader = get_property(dn, "loader", &size);
+        if (!loader)
+                return;
+
+        /* kmalloc should align on a 16 byte boundary..* */
+        isolated_loader = kmalloc(size, GFP_KERNEL);
+        if (!isolated_loader)
+                return;
+
+        memcpy(isolated_loader, loader, size);
+        printk(KERN_INFO "spufs: SPU isolation mode enabled\n");
+}
+
 static int
 spufs_create_root(struct super_block *sb, void *data)
 {
@@ -608,6 +652,7 @@ static struct file_system_type spufs_type = {
 static int __init spufs_init(void)
 {
         int ret;
+
         ret = -ENOMEM;
         spufs_inode_cache = kmem_cache_create("spufs_inode_cache",
                         sizeof(struct spufs_inode_info), 0,
@@ -625,6 +670,12 @@ static int __init spufs_init(void)
         ret = register_spu_syscalls(&spufs_calls);
         if (ret)
                 goto out_fs;
+        ret = register_arch_coredump_calls(&spufs_coredump_calls);
+        if (ret)
+                goto out_fs;
+
+        spufs_init_isolated_loader();
+
         return 0;
 out_fs:
         unregister_filesystem(&spufs_type);
@@ -638,6 +689,7 @@ module_init(spufs_init);
 static void __exit spufs_exit(void)
 {
         spu_sched_exit();
+        unregister_arch_coredump_calls(&spufs_coredump_calls);
         unregister_spu_syscalls(&spufs_calls);
         unregister_filesystem(&spufs_type);
         kmem_cache_destroy(spufs_inode_cache);
diff --git a/arch/powerpc/platforms/cell/spufs/run.c b/arch/powerpc/platforms/cell/spufs/run.c
index 63df8cf4ba16..1acc2ffef8c8 100644
--- a/arch/powerpc/platforms/cell/spufs/run.c
+++ b/arch/powerpc/platforms/cell/spufs/run.c
@@ -1,7 +1,11 @@
+#define DEBUG
+
 #include <linux/wait.h>
 #include <linux/ptrace.h>
 
 #include <asm/spu.h>
+#include <asm/spu_priv1.h>
+#include <asm/io.h>
 #include <asm/unistd.h>
 
 #include "spufs.h"
@@ -24,6 +28,7 @@ void spufs_dma_callback(struct spu *spu, int type)
         } else {
                 switch (type) {
                 case SPE_EVENT_DMA_ALIGNMENT:
+                case SPE_EVENT_SPE_DATA_STORAGE:
                 case SPE_EVENT_INVALID_DMA:
                         force_sig(SIGBUS, /* info, */ current);
                         break;
@@ -48,15 +53,122 @@ static inline int spu_stopped(struct spu_context *ctx, u32 * stat)
         return (!(*stat & 0x1) || pte_fault || spu->class_0_pending) ? 1 : 0;
 }
 
+static int spu_setup_isolated(struct spu_context *ctx)
+{
+        int ret;
+        u64 __iomem *mfc_cntl;
+        u64 sr1;
+        u32 status;
+        unsigned long timeout;
+        const u32 status_loading = SPU_STATUS_RUNNING
+                | SPU_STATUS_ISOLATED_STATE | SPU_STATUS_ISOLATED_LOAD_STATUS;
+
+        if (!isolated_loader)
+                return -ENODEV;
+
+        ret = spu_acquire_exclusive(ctx);
+        if (ret)
+                goto out;
+
+        mfc_cntl = &ctx->spu->priv2->mfc_control_RW;
+
+        /* purge the MFC DMA queue to ensure no spurious accesses before we
+         * enter kernel mode */
+        timeout = jiffies + HZ;
+        out_be64(mfc_cntl, MFC_CNTL_PURGE_DMA_REQUEST);
+        while ((in_be64(mfc_cntl) & MFC_CNTL_PURGE_DMA_STATUS_MASK)
+                        != MFC_CNTL_PURGE_DMA_COMPLETE) {
+                if (time_after(jiffies, timeout)) {
+                        printk(KERN_ERR "%s: timeout flushing MFC DMA queue\n",
+                                        __FUNCTION__);
+                        ret = -EIO;
+                        goto out_unlock;
+                }
+                cond_resched();
+        }
+
+        /* put the SPE in kernel mode to allow access to the loader */
+        sr1 = spu_mfc_sr1_get(ctx->spu);
+        sr1 &= ~MFC_STATE1_PROBLEM_STATE_MASK;
+        spu_mfc_sr1_set(ctx->spu, sr1);
+
+        /* start the loader */
+        ctx->ops->signal1_write(ctx, (unsigned long)isolated_loader >> 32);
+        ctx->ops->signal2_write(ctx,
+                        (unsigned long)isolated_loader & 0xffffffff);
+
+        ctx->ops->runcntl_write(ctx,
+                        SPU_RUNCNTL_RUNNABLE | SPU_RUNCNTL_ISOLATE);
+
+        ret = 0;
+        timeout = jiffies + HZ;
+        while (((status = ctx->ops->status_read(ctx)) & status_loading) ==
+                                status_loading) {
+                if (time_after(jiffies, timeout)) {
+                        printk(KERN_ERR "%s: timeout waiting for loader\n",
+                                        __FUNCTION__);
+                        ret = -EIO;
+                        goto out_drop_priv;
+                }
+                cond_resched();
+        }
+
+        if (!(status & SPU_STATUS_RUNNING)) {
+                /* If isolated LOAD has failed: run SPU, we will get a stop-and
+                 * signal later. */
+                pr_debug("%s: isolated LOAD failed\n", __FUNCTION__);
+                ctx->ops->runcntl_write(ctx, SPU_RUNCNTL_RUNNABLE);
+                ret = -EACCES;
+
+        } else if (!(status & SPU_STATUS_ISOLATED_STATE)) {
+                /* This isn't allowed by the CBEA, but check anyway */
+                pr_debug("%s: SPU fell out of isolated mode?\n", __FUNCTION__);
+                ctx->ops->runcntl_write(ctx, SPU_RUNCNTL_STOP);
+                ret = -EINVAL;
+        }
+
+out_drop_priv:
+        /* Finished accessing the loader. Drop kernel mode */
+        sr1 |= MFC_STATE1_PROBLEM_STATE_MASK;
+        spu_mfc_sr1_set(ctx->spu, sr1);
+
+out_unlock:
+        spu_release_exclusive(ctx);
+out:
+        return ret;
+}
+
 static inline int spu_run_init(struct spu_context *ctx, u32 * npc)
 {
         int ret;
+        unsigned long runcntl = SPU_RUNCNTL_RUNNABLE;
 
-        if ((ret = spu_acquire_runnable(ctx)) != 0)
+        ret = spu_acquire_runnable(ctx);
+        if (ret)
                 return ret;
-        ctx->ops->npc_write(ctx, *npc);
-        ctx->ops->runcntl_write(ctx, SPU_RUNCNTL_RUNNABLE);
-        return 0;
+
+        if (ctx->flags & SPU_CREATE_ISOLATE) {
+                if (!(ctx->ops->status_read(ctx) & SPU_STATUS_ISOLATED_STATE)) {
+                        /* Need to release ctx, because spu_setup_isolated will
+                         * acquire it exclusively.
+                         */
+                        spu_release(ctx);
+                        ret = spu_setup_isolated(ctx);
+                        if (!ret)
+                                ret = spu_acquire_runnable(ctx);
+                }
+
+                /* if userspace has set the runcntrl register (eg, to issue an
+                 * isolated exit), we need to re-set it here */
+                runcntl = ctx->ops->runcntl_read(ctx) &
+                        (SPU_RUNCNTL_RUNNABLE | SPU_RUNCNTL_ISOLATE);
+                if (runcntl == 0)
+                        runcntl = SPU_RUNCNTL_RUNNABLE;
+        } else
+                ctx->ops->npc_write(ctx, *npc);
+
+        ctx->ops->runcntl_write(ctx, runcntl);
+        return ret;
 }
 
 static inline int spu_run_fini(struct spu_context *ctx, u32 * npc,
@@ -70,13 +182,7 @@ static inline int spu_run_fini(struct spu_context *ctx, u32 * npc,
 
         if (signal_pending(current))
                 ret = -ERESTARTSYS;
-        if (unlikely(current->ptrace & PT_PTRACED)) {
-                if ((*status & SPU_STATUS_STOPPED_BY_STOP)
-                    && (*status >> SPU_STOP_STATUS_SHIFT) == 0x3fff) {
-                        force_sig(SIGTRAP, current);
-                        ret = -ERESTARTSYS;
-                }
-        }
+
         return ret;
 }
 
@@ -204,6 +310,7 @@ long spufs_run_spu(struct file *file, struct spu_context *ctx,
         if (down_interruptible(&ctx->run_sema))
                 return -ERESTARTSYS;
 
+        ctx->ops->master_start(ctx);
         ctx->event_return = 0;
         ret = spu_run_init(ctx, npc);
         if (ret)
@@ -223,7 +330,7 @@ long spufs_run_spu(struct file *file, struct spu_context *ctx,
                 if (unlikely(ctx->state != SPU_STATE_RUNNABLE)) {
                         ret = spu_reacquire_runnable(ctx, npc, &status);
                         if (ret)
-                                goto out;
+                                goto out2;
                         continue;
                 }
                 ret = spu_process_events(ctx);
@@ -231,12 +338,24 @@ long spufs_run_spu(struct file *file, struct spu_context *ctx,
         } while (!ret && !(status & (SPU_STATUS_STOPPED_BY_STOP |
                                       SPU_STATUS_STOPPED_BY_HALT)));
 
-        ctx->ops->runcntl_stop(ctx);
+        ctx->ops->master_stop(ctx);
         ret = spu_run_fini(ctx, npc, &status);
-        if (!ret)
-                ret = status;
         spu_yield(ctx);
 
+out2:
+        if ((ret == 0) ||
+            ((ret == -ERESTARTSYS) &&
+             ((status & SPU_STATUS_STOPPED_BY_HALT) ||
+              ((status & SPU_STATUS_STOPPED_BY_STOP) &&
+               (status >> SPU_STOP_STATUS_SHIFT != 0x2104)))))
+                ret = status;
+
+        if ((status & SPU_STATUS_STOPPED_BY_STOP)
+            && (status >> SPU_STOP_STATUS_SHIFT) == 0x3fff) {
+                force_sig(SIGTRAP, current);
+                ret = -ERESTARTSYS;
+        }
+
 out:
         *event = ctx->event_return;
         up(&ctx->run_sema);
diff --git a/arch/powerpc/platforms/cell/spufs/spufs.h b/arch/powerpc/platforms/cell/spufs/spufs.h
index a0f55ca2d488..70fb13395c04 100644
--- a/arch/powerpc/platforms/cell/spufs/spufs.h
+++ b/arch/powerpc/platforms/cell/spufs/spufs.h
@@ -29,6 +29,7 @@
 
 #include <asm/spu.h>
 #include <asm/spu_csa.h>
+#include <asm/spu_info.h>
 
 /* The magic number for our file system */
 enum {
@@ -114,13 +115,19 @@ struct spu_context_ops {
         void (*npc_write) (struct spu_context * ctx, u32 data);
          u32(*status_read) (struct spu_context * ctx);
         char*(*get_ls) (struct spu_context * ctx);
+         u32 (*runcntl_read) (struct spu_context * ctx);
         void (*runcntl_write) (struct spu_context * ctx, u32 data);
-        void (*runcntl_stop) (struct spu_context * ctx);
+        void (*master_start) (struct spu_context * ctx);
+        void (*master_stop) (struct spu_context * ctx);
         int (*set_mfc_query)(struct spu_context * ctx, u32 mask, u32 mode);
         u32 (*read_mfc_tagstatus)(struct spu_context * ctx);
         u32 (*get_mfc_free_elements)(struct spu_context *ctx);
-        int (*send_mfc_command)(struct spu_context *ctx,
-                                        struct mfc_dma_command *cmd);
+        int (*send_mfc_command)(struct spu_context * ctx,
+                                struct mfc_dma_command * cmd);
+        void (*dma_info_read) (struct spu_context * ctx,
+                               struct spu_dma_info * info);
+        void (*proxydma_info_read) (struct spu_context * ctx,
+                                    struct spu_proxydma_info * info);
 };
 
 extern struct spu_context_ops spu_hw_ops;
@@ -135,6 +142,7 @@ struct spufs_inode_info {
         container_of(inode, struct spufs_inode_info, vfs_inode)
 
 extern struct tree_descr spufs_dir_contents[];
+extern struct tree_descr spufs_dir_nosched_contents[];
 
 /* system call implementation */
 long spufs_run_spu(struct file *file,
@@ -162,6 +170,12 @@ void spu_acquire(struct spu_context *ctx);
 void spu_release(struct spu_context *ctx);
 int spu_acquire_runnable(struct spu_context *ctx);
 void spu_acquire_saved(struct spu_context *ctx);
+int spu_acquire_exclusive(struct spu_context *ctx);
+
+static inline void spu_release_exclusive(struct spu_context *ctx)
+{
+        up_write(&ctx->state_sema);
+}
 
 int spu_activate(struct spu_context *ctx, u64 flags);
 void spu_deactivate(struct spu_context *ctx);
@@ -169,6 +183,8 @@ void spu_yield(struct spu_context *ctx);
 int __init spu_sched_init(void);
 void __exit spu_sched_exit(void);
 
+extern char *isolated_loader;
+
 /*
  * spufs_wait
  *      Same as wait_event_interruptible(), except that here
@@ -207,4 +223,15 @@ void spufs_stop_callback(struct spu *spu);
 void spufs_mfc_callback(struct spu *spu);
 void spufs_dma_callback(struct spu *spu, int type);
 
+extern struct spu_coredump_calls spufs_coredump_calls;
+struct spufs_coredump_reader {
+        char *name;
+        ssize_t (*read)(struct spu_context *ctx,
+                        char __user *buffer, size_t size, loff_t *pos);
+        u64 (*get)(void *data);
+        size_t size;
+};
+extern struct spufs_coredump_reader spufs_coredump_read[];
+extern int spufs_coredump_num_notes;
+
 #endif
diff --git a/arch/powerpc/platforms/cell/spufs/switch.c b/arch/powerpc/platforms/cell/spufs/switch.c
index 0f782ca662ba..c08981ff7fc6 100644
--- a/arch/powerpc/platforms/cell/spufs/switch.c
+++ b/arch/powerpc/platforms/cell/spufs/switch.c
@@ -102,7 +102,7 @@ static inline int check_spu_isolate(struct spu_state *csa, struct spu *spu)
          *     saved at this time.
          */
         isolate_state = SPU_STATUS_ISOLATED_STATE |
-            SPU_STATUS_ISOLATED_LOAD_STAUTUS | SPU_STATUS_ISOLATED_EXIT_STAUTUS;
+            SPU_STATUS_ISOLATED_LOAD_STATUS | SPU_STATUS_ISOLATED_EXIT_STATUS;
         return (in_be32(&prob->spu_status_R) & isolate_state) ? 1 : 0;
 }
 
@@ -1046,12 +1046,12 @@ static inline int suspend_spe(struct spu_state *csa, struct spu *spu)
          */
         if (in_be32(&prob->spu_status_R) & SPU_STATUS_RUNNING) {
                 if (in_be32(&prob->spu_status_R) &
-                    SPU_STATUS_ISOLATED_EXIT_STAUTUS) {
+                    SPU_STATUS_ISOLATED_EXIT_STATUS) {
                         POLL_WHILE_TRUE(in_be32(&prob->spu_status_R) &
                                         SPU_STATUS_RUNNING);
                 }
                 if ((in_be32(&prob->spu_status_R) &
-                     SPU_STATUS_ISOLATED_LOAD_STAUTUS)
+                     SPU_STATUS_ISOLATED_LOAD_STATUS)
                     || (in_be32(&prob->spu_status_R) &
                         SPU_STATUS_ISOLATED_STATE)) {
                         out_be32(&prob->spu_runcntl_RW, SPU_RUNCNTL_STOP);
@@ -1085,7 +1085,7 @@ static inline void clear_spu_status(struct spu_state *csa, struct spu *spu)
          */
         if (!(in_be32(&prob->spu_status_R) & SPU_STATUS_RUNNING)) {
                 if (in_be32(&prob->spu_status_R) &
-                    SPU_STATUS_ISOLATED_EXIT_STAUTUS) {
+                    SPU_STATUS_ISOLATED_EXIT_STATUS) {
                         spu_mfc_sr1_set(spu,
                                         MFC_STATE1_MASTER_RUN_CONTROL_MASK);
                         eieio();
@@ -1095,7 +1095,7 @@ static inline void clear_spu_status(struct spu_state *csa, struct spu *spu)
                                         SPU_STATUS_RUNNING);
                 }
                 if ((in_be32(&prob->spu_status_R) &
-                     SPU_STATUS_ISOLATED_LOAD_STAUTUS)
+                     SPU_STATUS_ISOLATED_LOAD_STATUS)
                     || (in_be32(&prob->spu_status_R) &
                         SPU_STATUS_ISOLATED_STATE)) {
                         spu_mfc_sr1_set(spu,
@@ -1916,6 +1916,51 @@ static void save_lscsa(struct spu_state *prev, struct spu *spu)
         wait_spu_stopped(prev, spu);    /* Step 57. */
 }
 
+static void force_spu_isolate_exit(struct spu *spu)
+{
+        struct spu_problem __iomem *prob = spu->problem;
+        struct spu_priv2 __iomem *priv2 = spu->priv2;
+
+        /* Stop SPE execution and wait for completion. */
+        out_be32(&prob->spu_runcntl_RW, SPU_RUNCNTL_STOP);
+        iobarrier_rw();
+        POLL_WHILE_TRUE(in_be32(&prob->spu_status_R) & SPU_STATUS_RUNNING);
+
+        /* Restart SPE master runcntl. */
+        spu_mfc_sr1_set(spu, MFC_STATE1_MASTER_RUN_CONTROL_MASK);
+        iobarrier_w();
+
+        /* Initiate isolate exit request and wait for completion. */
+        out_be64(&priv2->spu_privcntl_RW, 4LL);
+        iobarrier_w();
+        out_be32(&prob->spu_runcntl_RW, 2);
+        iobarrier_rw();
+        POLL_WHILE_FALSE((in_be32(&prob->spu_status_R)
+                                & SPU_STATUS_STOPPED_BY_STOP));
+
+        /* Reset load request to normal. */
+        out_be64(&priv2->spu_privcntl_RW, SPU_PRIVCNT_LOAD_REQUEST_NORMAL);
+        iobarrier_w();
+}
+
+/**
+ * stop_spu_isolate
+ *      Check SPU run-control state and force isolated
+ *      exit function as necessary.
+ */
+static void stop_spu_isolate(struct spu *spu)
+{
+        struct spu_problem __iomem *prob = spu->problem;
+
+        if (in_be32(&prob->spu_status_R) & SPU_STATUS_ISOLATED_STATE) {
+                /* The SPU is in isolated state; the only way
+                 * to get it out is to perform an isolated
+                 * exit (clean) operation.
+                 */
+                force_spu_isolate_exit(spu);
+        }
+}
+
 static void harvest(struct spu_state *prev, struct spu *spu)
 {
         /*
@@ -1928,6 +1973,7 @@ static void harvest(struct spu_state *prev, struct spu *spu)
         inhibit_user_access(prev, spu);         /* Step 3.  */
         terminate_spu_app(prev, spu);           /* Step 4.  */
         set_switch_pending(prev, spu);          /* Step 5.  */
+        stop_spu_isolate(spu);                  /* NEW.     */
         remove_other_spu_access(prev, spu);     /* Step 6.  */
         suspend_mfc(prev, spu);                 /* Step 7.  */
         wait_suspend_mfc_complete(prev, spu);   /* Step 8.  */
@@ -2096,11 +2142,11 @@ int spu_save(struct spu_state *prev, struct spu *spu)
         acquire_spu_lock(spu);          /* Step 1.     */
         rc = __do_spu_save(prev, spu);  /* Steps 2-53. */
         release_spu_lock(spu);
-        if (rc) {
+        if (rc != 0 && rc != 2 && rc != 6) {
                 panic("%s failed on SPU[%d], rc=%d.\n",
                       __func__, spu->number, rc);
         }
-        return rc;
+        return 0;
 }
 EXPORT_SYMBOL_GPL(spu_save);
 
@@ -2165,9 +2211,6 @@ static void init_priv1(struct spu_state *csa)
             MFC_STATE1_PROBLEM_STATE_MASK |
             MFC_STATE1_RELOCATE_MASK | MFC_STATE1_BUS_TLBIE_MASK;
 
-        /* Set storage description.  */
-        csa->priv1.mfc_sdr_RW = mfspr(SPRN_SDR1);
-
         /* Enable OS-specific set of interrupts. */
         csa->priv1.int_mask_class0_RW = CLASS0_ENABLE_DMA_ALIGNMENT_INTR |
             CLASS0_ENABLE_INVALID_DMA_COMMAND_INTR |
diff --git a/arch/powerpc/platforms/cell/spufs/syscalls.c b/arch/powerpc/platforms/cell/spufs/syscalls.c
index a6d1ae4dc2a3..8e37bdf4dfda 100644
--- a/arch/powerpc/platforms/cell/spufs/syscalls.c
+++ b/arch/powerpc/platforms/cell/spufs/syscalls.c
@@ -46,7 +46,7 @@ static long do_spu_run(struct file *filp,
         if (filp->f_op != &spufs_context_fops)
                 goto out;
 
-        i = SPUFS_I(filp->f_dentry->d_inode);
+        i = SPUFS_I(filp->f_path.dentry->d_inode);
         ret = spufs_run_spu(filp, i->i_ctx, &npc, &status);
 
         if (put_user(npc, unpc))
diff --git a/arch/powerpc/platforms/chrp/chrp.h b/arch/powerpc/platforms/chrp/chrp.h
index 996c28744e96..63f0aee4c158 100644
--- a/arch/powerpc/platforms/chrp/chrp.h
+++ b/arch/powerpc/platforms/chrp/chrp.h
@@ -9,4 +9,3 @@ extern long chrp_time_init(void);
 
 extern void chrp_find_bridges(void);
 extern void chrp_event_scan(unsigned long);
-extern void chrp_pcibios_fixup(void);
diff --git a/arch/powerpc/platforms/chrp/pci.c b/arch/powerpc/platforms/chrp/pci.c
index 0f4340506c75..ddb4a116ea89 100644
--- a/arch/powerpc/platforms/chrp/pci.c
+++ b/arch/powerpc/platforms/chrp/pci.c
@@ -156,15 +156,6 @@ hydra_init(void)
         return 1;
 }
 
-void __init
-chrp_pcibios_fixup(void)
-{
-        struct pci_dev *dev = NULL;
-
-        for_each_pci_dev(dev)
-                pci_read_irq_line(dev);
-}
-
 #define PRG_CL_RESET_VALID 0x00010000
 
 static void __init
diff --git a/arch/powerpc/platforms/chrp/setup.c b/arch/powerpc/platforms/chrp/setup.c
index 49b8dabcbc99..e1f51d455984 100644
--- a/arch/powerpc/platforms/chrp/setup.c
+++ b/arch/powerpc/platforms/chrp/setup.c
@@ -588,7 +588,6 @@ static int __init chrp_probe(void)
         ISA_DMA_THRESHOLD = ~0L;
         DMA_MODE_READ = 0x44;
         DMA_MODE_WRITE = 0x48;
-        isa_io_base = CHRP_ISA_IO_BASE;         /* default value */
 
         return 1;
 }
@@ -600,7 +599,6 @@ define_machine(chrp) {
         .init                   = chrp_init2,
         .show_cpuinfo           = chrp_show_cpuinfo,
         .init_IRQ               = chrp_init_IRQ,
-        .pcibios_fixup          = chrp_pcibios_fixup,
         .restart                = rtas_restart,
         .power_off              = rtas_power_off,
         .halt                   = rtas_halt,
diff --git a/arch/powerpc/platforms/embedded6xx/Kconfig b/arch/powerpc/platforms/embedded6xx/Kconfig
index 234a861870a8..b3c2ce4cb7a8 100644
--- a/arch/powerpc/platforms/embedded6xx/Kconfig
+++ b/arch/powerpc/platforms/embedded6xx/Kconfig
@@ -35,7 +35,7 @@ config HDPU
           Select HDPU if configuring a Sky Computers Compute Blade.
 
 config HDPU_FEATURES
-        depends HDPU
+        depends on HDPU
         tristate "HDPU-Features"
         help
           Select to enable HDPU enhanced features.
@@ -74,6 +74,18 @@ config SANDPOINT
           Select SANDPOINT if configuring for a Motorola Sandpoint X3
           (any flavor).
 
+config LINKSTATION
+        bool "Linkstation / Kurobox(HG) from Buffalo"
+        select MPIC
+        select FSL_SOC
+        select PPC_UDBG_16550 if SERIAL_8250
+        help
+          Select LINKSTATION if configuring for one of PPC- (MPC8241)
+          based NAS systems from Buffalo Technology. So far only
+          KuroboxHG has been tested. In the future classical Kurobox,
+          Linkstation-I HD-HLAN and HD-HGLAN versions, and PPC-based
+          Terastation systems should be supported too.
+
 config MPC7448HPC2
         bool "Freescale MPC7448HPC2(Taiga)"
         select TSI108_BRIDGE
@@ -146,15 +158,6 @@ config PQ2FADS
           Select PQ2FADS if you wish to configure for a Freescale
           PQ2FADS board (-VR or -ZU).
 
-config LITE5200
-        bool "Freescale LITE5200 / (IceCube)"
-        select PPC_MPC52xx
-        help
-          Support for the LITE5200 dev board for the MPC5200 from Freescale.
-          This is for the LITE5200 version 2.0 board. Don't know if it changes
-          much but it's only been tested on this board version. I think this
-          board is also known as IceCube.
-
 config EV64360
         bool "Marvell-EV64360BP"
         help
@@ -172,9 +175,6 @@ config TQM8xxL
         depends on 8xx && (TQM823L || TQM850L || FPS850L || TQM855L || TQM860L)
         default y
 
-config PPC_MPC52xx
-        bool
-
 config 8260
         bool "CPM2 Support" if WILLOW
         depends on 6xx
@@ -208,7 +208,7 @@ config PPC_GEN550
         depends on SANDPOINT || SPRUCE || PPLUS || \
                 PRPMC750 || PRPMC800 || LOPEC || \
                 (EV64260 && !SERIAL_MPSC) || CHESTNUT || RADSTONE_PPC7D || \
-                83xx
+                83xx || LINKSTATION
         default y
 
 config FORCE
@@ -282,13 +282,13 @@ config EPIC_SERIAL_MODE
 
 config MPC10X_BRIDGE
         bool
-        depends on POWERPMC250 || LOPEC || SANDPOINT
+        depends on POWERPMC250 || LOPEC || SANDPOINT || LINKSTATION
         select PPC_INDIRECT_PCI
         default y
 
 config MPC10X_OPENPIC
         bool
-        depends on POWERPMC250 || LOPEC || SANDPOINT
+        depends on POWERPMC250 || LOPEC || SANDPOINT || LINKSTATION
         default y
 
 config MPC10X_STORE_GATHERING
diff --git a/arch/powerpc/platforms/embedded6xx/Makefile b/arch/powerpc/platforms/embedded6xx/Makefile
index fa499fe59291..d3d11a3cd656 100644
--- a/arch/powerpc/platforms/embedded6xx/Makefile
+++ b/arch/powerpc/platforms/embedded6xx/Makefile
@@ -2,3 +2,4 @@
 # Makefile for the 6xx/7xx/7xxxx linux kernel.
 #
 obj-$(CONFIG_MPC7448HPC2)       += mpc7448_hpc2.o
+obj-$(CONFIG_LINKSTATION)       += linkstation.o ls_uart.o
diff --git a/arch/powerpc/platforms/embedded6xx/linkstation.c b/arch/powerpc/platforms/embedded6xx/linkstation.c
new file mode 100644
index 000000000000..61599d919ea8
--- /dev/null
+++ b/arch/powerpc/platforms/embedded6xx/linkstation.c
@@ -0,0 +1,211 @@
+/*
+ * Board setup routines for the Buffalo Linkstation / Kurobox Platform.
+ *
+ * Copyright (C) 2006 G. Liakhovetski (g.liakhovetski@gmx.de)
+ *
+ * Based on sandpoint.c by Mark A. Greer
+ *
+ * This file is licensed under the terms of the GNU General Public License
+ * version 2.  This program is licensed "as is" without any warranty of
+ * any kind, whether express or implied.
+ */
+
+#include <linux/kernel.h>
+#include <linux/pci.h>
+#include <linux/initrd.h>
+#include <linux/root_dev.h>
+#include <linux/mtd/physmap.h>
+
+#include <asm/time.h>
+#include <asm/prom.h>
+#include <asm/mpic.h>
+#include <asm/mpc10x.h>
+#include <asm/pci-bridge.h>
+
+static struct mtd_partition linkstation_physmap_partitions[] = {
+        {
+                .name   = "mtd_firmimg",
+                .offset = 0x000000,
+                .size   = 0x300000,
+        },
+        {
+                .name   = "mtd_bootcode",
+                .offset = 0x300000,
+                .size   = 0x070000,
+        },
+        {
+                .name   = "mtd_status",
+                .offset = 0x370000,
+                .size   = 0x010000,
+        },
+        {
+                .name   = "mtd_conf",
+                .offset = 0x380000,
+                .size   = 0x080000,
+        },
+        {
+                .name   = "mtd_allflash",
+                .offset = 0x000000,
+                .size   = 0x400000,
+        },
+        {
+                .name   = "mtd_data",
+                .offset = 0x310000,
+                .size   = 0x0f0000,
+        },
+};
+
+static int __init add_bridge(struct device_node *dev)
+{
+        int len;
+        struct pci_controller *hose;
+        int *bus_range;
+
+        printk("Adding PCI host bridge %s\n", dev->full_name);
+
+        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 == NULL)
+                return -ENOMEM;
+        hose->first_busno = bus_range ? bus_range[0] : 0;
+        hose->last_busno = bus_range ? bus_range[1] : 0xff;
+        hose->arch_data = dev;
+        setup_indirect_pci(hose, 0xfec00000, 0xfee00000);
+
+        /* Interpret the "ranges" property */
+        /* This also maps the I/O region and sets isa_io/mem_base */
+        pci_process_bridge_OF_ranges(hose, dev, 1);
+
+        return 0;
+}
+
+static void __init linkstation_setup_arch(void)
+{
+        struct device_node *np;
+#ifdef CONFIG_MTD_PHYSMAP
+        physmap_set_partitions(linkstation_physmap_partitions,
+                               ARRAY_SIZE(linkstation_physmap_partitions));
+#endif
+
+#ifdef CONFIG_BLK_DEV_INITRD
+        if (initrd_start)
+                ROOT_DEV = Root_RAM0;
+        else
+#endif
+#ifdef  CONFIG_ROOT_NFS
+                ROOT_DEV = Root_NFS;
+#else
+                ROOT_DEV = Root_HDA1;
+#endif
+
+        /* Lookup PCI host bridges */
+        for (np = NULL; (np = of_find_node_by_type(np, "pci")) != NULL;)
+                add_bridge(np);
+
+        printk(KERN_INFO "BUFFALO Network Attached Storage Series\n");
+        printk(KERN_INFO "(C) 2002-2005 BUFFALO INC.\n");
+}
+
+/*
+ * Interrupt setup and service.  Interrrupts on the linkstation come
+ * from the four PCI slots plus onboard 8241 devices: I2C, DUART.
+ */
+static void __init linkstation_init_IRQ(void)
+{
+        struct mpic *mpic;
+        struct device_node *dnp;
+        void *prop;
+        int size;
+        phys_addr_t paddr;
+
+        dnp = of_find_node_by_type(NULL, "open-pic");
+        if (dnp == NULL)
+                return;
+
+        prop = (struct device_node *)get_property(dnp, "reg", &size);
+        paddr = (phys_addr_t)of_translate_address(dnp, prop);
+
+        mpic = mpic_alloc(dnp, paddr, MPIC_PRIMARY | MPIC_WANTS_RESET, 4, 32, " EPIC     ");
+        BUG_ON(mpic == NULL);
+
+        /* PCI IRQs */
+        mpic_assign_isu(mpic, 0, paddr + 0x10200);
+
+        /* I2C */
+        mpic_assign_isu(mpic, 1, paddr + 0x11000);
+
+        /* ttyS0, ttyS1 */
+        mpic_assign_isu(mpic, 2, paddr + 0x11100);
+
+        mpic_init(mpic);
+}
+
+extern void avr_uart_configure(void);
+extern void avr_uart_send(const char);
+
+static void linkstation_restart(char *cmd)
+{
+        local_irq_disable();
+
+        /* Reset system via AVR */
+        avr_uart_configure();
+        /* Send reboot command */
+        avr_uart_send('C');
+
+        for(;;)  /* Spin until reset happens */
+                avr_uart_send('G');     /* "kick" */
+}
+
+static void linkstation_power_off(void)
+{
+        local_irq_disable();
+
+        /* Power down system via AVR */
+        avr_uart_configure();
+        /* send shutdown command */
+        avr_uart_send('E');
+
+        for(;;)  /* Spin until power-off happens */
+                avr_uart_send('G');     /* "kick" */
+        /* NOTREACHED */
+}
+
+static void linkstation_halt(void)
+{
+        linkstation_power_off();
+        /* NOTREACHED */
+}
+
+static void linkstation_show_cpuinfo(struct seq_file *m)
+{
+        seq_printf(m, "vendor\t\t: Buffalo Technology\n");
+        seq_printf(m, "machine\t\t: Linkstation I/Kurobox(HG)\n");
+}
+
+static int __init linkstation_probe(void)
+{
+        unsigned long root;
+
+        root = of_get_flat_dt_root();
+
+        if (!of_flat_dt_is_compatible(root, "linkstation"))
+                return 0;
+        return 1;
+}
+
+define_machine(linkstation){
+        .name                   = "Buffalo Linkstation",
+        .probe                  = linkstation_probe,
+        .setup_arch             = linkstation_setup_arch,
+        .init_IRQ               = linkstation_init_IRQ,
+        .show_cpuinfo           = linkstation_show_cpuinfo,
+        .get_irq                = mpic_get_irq,
+        .restart                = linkstation_restart,
+        .power_off              = linkstation_power_off,
+        .halt                   = linkstation_halt,
+        .calibrate_decr         = generic_calibrate_decr,
+};
diff --git a/arch/powerpc/platforms/embedded6xx/ls_uart.c b/arch/powerpc/platforms/embedded6xx/ls_uart.c
new file mode 100644
index 000000000000..0e837762cc5b
--- /dev/null
+++ b/arch/powerpc/platforms/embedded6xx/ls_uart.c
@@ -0,0 +1,131 @@
+#include <linux/workqueue.h>
+#include <linux/string.h>
+#include <linux/delay.h>
+#include <linux/serial_reg.h>
+#include <linux/serial_8250.h>
+#include <asm/io.h>
+#include <asm/mpc10x.h>
+#include <asm/ppc_sys.h>
+#include <asm/prom.h>
+#include <asm/termbits.h>
+
+static void __iomem *avr_addr;
+static unsigned long avr_clock;
+
+static struct work_struct wd_work;
+
+static void wd_stop(struct work_struct *unused)
+{
+        const char string[] = "AAAAFFFFJJJJ>>>>VVVV>>>>ZZZZVVVVKKKK";
+        int i = 0, rescue = 8;
+        int len = strlen(string);
+
+        while (rescue--) {
+                int j;
+                char lsr = in_8(avr_addr + UART_LSR);
+
+                if (lsr & (UART_LSR_THRE | UART_LSR_TEMT)) {
+                        for (j = 0; j < 16 && i < len; j++, i++)
+                                out_8(avr_addr + UART_TX, string[i]);
+                        if (i == len) {
+                                /* Read "OK" back: 4ms for the last "KKKK"
+                                   plus a couple bytes back */
+                                msleep(7);
+                                printk("linkstation: disarming the AVR watchdog: ");
+                                while (in_8(avr_addr + UART_LSR) & UART_LSR_DR)
+                                        printk("%c", in_8(avr_addr + UART_RX));
+                                break;
+                        }
+                }
+                msleep(17);
+        }
+        printk("\n");
+}
+
+#define AVR_QUOT(clock) ((clock) + 8 * 9600) / (16 * 9600)
+
+void avr_uart_configure(void)
+{
+        unsigned char cval = UART_LCR_WLEN8;
+        unsigned int quot = AVR_QUOT(avr_clock);
+
+        if (!avr_addr || !avr_clock)
+                return;
+
+        out_8(avr_addr + UART_LCR, cval);                       /* initialise UART */
+        out_8(avr_addr + UART_MCR, 0);
+        out_8(avr_addr + UART_IER, 0);
+
+        cval |= UART_LCR_STOP | UART_LCR_PARITY | UART_LCR_EPAR;
+
+        out_8(avr_addr + UART_LCR, cval);                       /* Set character format */
+
+        out_8(avr_addr + UART_LCR, cval | UART_LCR_DLAB);       /* set DLAB */
+        out_8(avr_addr + UART_DLL, quot & 0xff);                /* LS of divisor */
+        out_8(avr_addr + UART_DLM, quot >> 8);                  /* MS of divisor */
+        out_8(avr_addr + UART_LCR, cval);                       /* reset DLAB */
+        out_8(avr_addr + UART_FCR, UART_FCR_ENABLE_FIFO);       /* enable FIFO */
+}
+
+void avr_uart_send(const char c)
+{
+        if (!avr_addr || !avr_clock)
+                return;
+
+        out_8(avr_addr + UART_TX, c);
+        out_8(avr_addr + UART_TX, c);
+        out_8(avr_addr + UART_TX, c);
+        out_8(avr_addr + UART_TX, c);
+}
+
+static void __init ls_uart_init(void)
+{
+        local_irq_disable();
+
+#ifndef CONFIG_SERIAL_8250
+        out_8(avr_addr + UART_FCR, UART_FCR_ENABLE_FIFO);       /* enable FIFO */
+        out_8(avr_addr + UART_FCR, UART_FCR_ENABLE_FIFO |
+              UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT);       /* clear FIFOs */
+        out_8(avr_addr + UART_FCR, 0);
+        out_8(avr_addr + UART_IER, 0);
+
+        /* Clear up interrupts */
+        (void) in_8(avr_addr + UART_LSR);
+        (void) in_8(avr_addr + UART_RX);
+        (void) in_8(avr_addr + UART_IIR);
+        (void) in_8(avr_addr + UART_MSR);
+#endif
+        avr_uart_configure();
+
+        local_irq_enable();
+}
+
+static int __init ls_uarts_init(void)
+{
+        struct device_node *avr;
+        phys_addr_t phys_addr;
+        int len;
+
+        avr = of_find_node_by_path("/soc10x/serial@80004500");
+        if (!avr)
+                return -EINVAL;
+
+        avr_clock = *(u32*)get_property(avr, "clock-frequency", &len);
+        phys_addr = ((u32*)get_property(avr, "reg", &len))[0];
+
+        if (!avr_clock || !phys_addr)
+                return -EINVAL;
+
+        avr_addr = ioremap(phys_addr, 32);
+        if (!avr_addr)
+                return -EFAULT;
+
+        ls_uart_init();
+
+        INIT_WORK(&wd_work, wd_stop);
+        schedule_work(&wd_work);
+
+        return 0;
+}
+
+late_initcall(ls_uarts_init);
diff --git a/arch/powerpc/platforms/embedded6xx/mpc7448_hpc2.c b/arch/powerpc/platforms/embedded6xx/mpc7448_hpc2.c
index bdb475c65cba..3fcc85f60fbf 100644
--- a/arch/powerpc/platforms/embedded6xx/mpc7448_hpc2.c
+++ b/arch/powerpc/platforms/embedded6xx/mpc7448_hpc2.c
@@ -60,7 +60,7 @@ pci_dram_offset = MPC7448_HPC2_PCI_MEM_OFFSET;
 
 extern int tsi108_setup_pci(struct device_node *dev);
 extern void _nmask_and_or_msr(unsigned long nmask, unsigned long or_val);
-extern void tsi108_pci_int_init(void);
+extern void tsi108_pci_int_init(struct device_node *node);
 extern void tsi108_irq_cascade(unsigned int irq, struct irq_desc *desc);
 
 int mpc7448_hpc2_exclude_device(u_char bus, u_char devfn)
@@ -71,65 +71,6 @@ int mpc7448_hpc2_exclude_device(u_char bus, u_char devfn)
                 return PCIBIOS_SUCCESSFUL;
 }
 
-/*
- * find pci slot by devfn in interrupt map of OF tree
- */
-u8 find_slot_by_devfn(unsigned int *interrupt_map, unsigned int devfn)
-{
-        int i;
-        unsigned int tmp;
-        for (i = 0; i < 4; i++){
-                tmp = interrupt_map[i*4*7];
-                if ((tmp >> 11) == (devfn >> 3))
-                        return i;
-        }
-        return i;
-}
-
-/*
- * Scans the interrupt map for pci device
- */
-void mpc7448_hpc2_fixup_irq(struct pci_dev *dev)
-{
-        struct pci_controller *hose;
-        struct device_node *node;
-        const unsigned int *interrupt;
-        int busnr;
-        int len;
-        u8 slot;
-        u8 pin;
-
-        /* Lookup the hose */
-        busnr = dev->bus->number;
-        hose = pci_bus_to_hose(busnr);
-        if (!hose)
-                printk(KERN_ERR "No pci hose found\n");
-
-        /* Check it has an OF node associated */
-        node = (struct device_node *) hose->arch_data;
-        if (!node)
-                printk(KERN_ERR "No pci node found\n");
-
-        interrupt = get_property(node, "interrupt-map", &len);
-        slot = find_slot_by_devfn(interrupt, dev->devfn);
-        pci_read_config_byte(dev, PCI_INTERRUPT_PIN, &pin);
-        if (pin == 0 || pin > 4)
-                pin = 1;
-        pin--;
-        dev->irq  = interrupt[slot*4*7 + pin*7 + 5];
-        DBG("TSI_PCI: dev->irq = 0x%x\n", dev->irq);
-}
-/* temporary pci irq map fixup*/
-
-void __init mpc7448_hpc2_pcibios_fixup(void)
-{
-        struct pci_dev *dev = NULL;
-        for_each_pci_dev(dev) {
-                mpc7448_hpc2_fixup_irq(dev);
-                pci_write_config_byte(dev, PCI_INTERRUPT_LINE, dev->irq);
-        }
-}
-
 static void __init mpc7448_hpc2_setup_arch(void)
 {
         struct device_node *cpu;
@@ -192,9 +133,12 @@ static void __init mpc7448_hpc2_init_IRQ(void)
 {
         struct mpic *mpic;
         phys_addr_t mpic_paddr = 0;
+        struct device_node *tsi_pic;
+#ifdef CONFIG_PCI
         unsigned int cascade_pci_irq;
         struct device_node *tsi_pci;
-        struct device_node *tsi_pic;
+        struct device_node *cascade_node = NULL;
+#endif
 
         tsi_pic = of_find_node_by_type(NULL, "open-pic");
         if (tsi_pic) {
@@ -208,31 +152,41 @@ static void __init mpc7448_hpc2_init_IRQ(void)
                 return;
         }
 
-        DBG("%s: tsi108pic phys_addr = 0x%x\n", __FUNCTION__,
+        DBG("%s: tsi108 pic phys_addr = 0x%x\n", __FUNCTION__,
             (u32) mpic_paddr);
 
         mpic = mpic_alloc(tsi_pic, mpic_paddr,
                         MPIC_PRIMARY | MPIC_BIG_ENDIAN | MPIC_WANTS_RESET |
                         MPIC_SPV_EOI | MPIC_NO_PTHROU_DIS | MPIC_REGSET_TSI108,
-                        0, /* num_sources used */
-                        0, /* num_sources used */
+                        24,
+                        NR_IRQS-4, /* num_sources used */
                         "Tsi108_PIC");
 
-        BUG_ON(mpic == NULL); /* XXXX */
+        BUG_ON(mpic == NULL);
+
+        mpic_assign_isu(mpic, 0, mpic_paddr + 0x100);
+
         mpic_init(mpic);
 
+#ifdef CONFIG_PCI
         tsi_pci = of_find_node_by_type(NULL, "pci");
-        if (tsi_pci == 0) {
+        if (tsi_pci == NULL) {
                 printk("%s: No tsi108 pci node found !\n", __FUNCTION__);
                 return;
         }
+        cascade_node = of_find_node_by_type(NULL, "pic-router");
+        if (cascade_node == NULL) {
+                printk("%s: No tsi108 pci cascade node found !\n", __FUNCTION__);
+                return;
+        }
 
         cascade_pci_irq = irq_of_parse_and_map(tsi_pci, 0);
+        DBG("%s: tsi108 cascade_pci_irq = 0x%x\n", __FUNCTION__,
+            (u32) cascade_pci_irq);
+        tsi108_pci_int_init(cascade_node);
         set_irq_data(cascade_pci_irq, mpic);
         set_irq_chained_handler(cascade_pci_irq, tsi108_irq_cascade);
-
-        tsi108_pci_int_init();
-
+#endif
         /* Configure MPIC outputs to CPU0 */
         tsi108_write_reg(TSI108_MPIC_OFFSET + 0x30c, 0);
         of_node_put(tsi_pic);
@@ -290,7 +244,6 @@ static int mpc7448_machine_check_exception(struct pt_regs *regs)
                 return 1;
         }
         return 0;
-
 }
 
 define_machine(mpc7448_hpc2){
@@ -300,7 +253,6 @@ define_machine(mpc7448_hpc2){
         .init_IRQ               = mpc7448_hpc2_init_IRQ,
         .show_cpuinfo           = mpc7448_hpc2_show_cpuinfo,
         .get_irq                = mpic_get_irq,
-        .pcibios_fixup          = mpc7448_hpc2_pcibios_fixup,
         .restart                = mpc7448_hpc2_restart,
         .calibrate_decr         = generic_calibrate_decr,
         .machine_check_exception= mpc7448_machine_check_exception,
diff --git a/arch/powerpc/platforms/iseries/Kconfig b/arch/powerpc/platforms/iseries/Kconfig
index 887b68804e6d..54e6b3b6f261 100644
--- a/arch/powerpc/platforms/iseries/Kconfig
+++ b/arch/powerpc/platforms/iseries/Kconfig
@@ -31,5 +31,5 @@ endmenu
 
 config VIOPATH
         bool
-        depends on VIOCONS || VIODASD || VIOCD || VIOTAPE || VETH
+        depends on VIOCONS || VIODASD || VIOCD || VIOTAPE || ISERIES_VETH
         default y
diff --git a/arch/powerpc/platforms/iseries/Makefile b/arch/powerpc/platforms/iseries/Makefile
index dee4eb4d8bec..13ac3015d91c 100644
--- a/arch/powerpc/platforms/iseries/Makefile
+++ b/arch/powerpc/platforms/iseries/Makefile
@@ -1,5 +1,7 @@
 EXTRA_CFLAGS    += -mno-minimal-toc
 
+extra-y += dt.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
@@ -7,5 +9,9 @@ obj-$(CONFIG_SMP) += smp.o
 obj-$(CONFIG_VIOPATH) += viopath.o
 obj-$(CONFIG_MODULES) += ksyms.o
 
+quiet_cmd_dt_strings = DT_STR  $@
+      cmd_dt_strings = $(OBJCOPY) --rename-section .rodata.str1.8=.dt_strings \
+                                $< $@
+
 $(obj)/dt_mod.o:        $(obj)/dt.o
-        @$(OBJCOPY) --rename-section .rodata.str1.8=.dt_strings $(obj)/dt.o $(obj)/dt_mod.o
+        $(call if_changed,dt_strings)
diff --git a/arch/powerpc/platforms/iseries/dt.c b/arch/powerpc/platforms/iseries/dt.c
index e305deee7f44..9e8a334a518a 100644
--- a/arch/powerpc/platforms/iseries/dt.c
+++ b/arch/powerpc/platforms/iseries/dt.c
@@ -41,6 +41,7 @@
 #include "call_pci.h"
 #include "pci.h"
 #include "it_exp_vpd_panel.h"
+#include "naca.h"
 
 #ifdef DEBUG
 #define DBG(fmt...) udbg_printf(fmt)
@@ -205,13 +206,11 @@ static void __init dt_prop_u32(struct iseries_flat_dt *dt, const char *name,
         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)
@@ -306,6 +305,17 @@ static void __init dt_model(struct iseries_flat_dt *dt)
         dt_prop_u32(dt, "ibm,partition-no", HvLpConfig_getLpIndex());
 }
 
+static void __init dt_initrd(struct iseries_flat_dt *dt)
+{
+#ifdef CONFIG_BLK_DEV_INITRD
+        if (naca.xRamDisk) {
+                dt_prop_u64(dt, "linux,initrd-start", (u64)naca.xRamDisk);
+                dt_prop_u64(dt, "linux,initrd-end",
+                        (u64)naca.xRamDisk + naca.xRamDiskSize * HW_PAGE_SIZE);
+        }
+#endif
+}
+
 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)
@@ -641,6 +651,7 @@ void * __init build_flat_dt(unsigned long phys_mem_size)
         /* /chosen */
         dt_start_node(iseries_dt, "chosen");
         dt_prop_str(iseries_dt, "bootargs", cmd_line);
+        dt_initrd(iseries_dt);
         dt_end_node(iseries_dt);
 
         dt_cpus(iseries_dt);
diff --git a/arch/powerpc/platforms/iseries/iommu.c b/arch/powerpc/platforms/iseries/iommu.c
index 218817d13c5c..d7a756d5135c 100644
--- a/arch/powerpc/platforms/iseries/iommu.c
+++ b/arch/powerpc/platforms/iseries/iommu.c
@@ -27,6 +27,7 @@
 #include <linux/types.h>
 #include <linux/dma-mapping.h>
 #include <linux/list.h>
+#include <linux/pci.h>
 
 #include <asm/iommu.h>
 #include <asm/tce.h>
@@ -114,12 +115,10 @@ void iommu_table_getparms_iSeries(unsigned long busno,
 {
         struct iommu_table_cb *parms;
 
-        parms = kmalloc(sizeof(*parms), GFP_KERNEL);
+        parms = kzalloc(sizeof(*parms), GFP_KERNEL);
         if (parms == NULL)
                 panic("PCI_DMA: TCE Table Allocation failed.");
 
-        memset(parms, 0, sizeof(*parms));
-
         parms->itc_busno = busno;
         parms->itc_slotno = slotno;
         parms->itc_virtbus = virtbus;
@@ -168,7 +167,7 @@ static struct iommu_table *iommu_table_find(struct iommu_table * tbl)
 }
 
 
-void iommu_devnode_init_iSeries(struct device_node *dn)
+void iommu_devnode_init_iSeries(struct pci_dev *pdev, struct device_node *dn)
 {
         struct iommu_table *tbl;
         struct pci_dn *pdn = PCI_DN(dn);
@@ -186,19 +185,14 @@ void iommu_devnode_init_iSeries(struct device_node *dn)
                 pdn->iommu_table = iommu_init_table(tbl, -1);
         else
                 kfree(tbl);
+        pdev->dev.archdata.dma_data = pdn->iommu_table;
 }
 #endif
 
-static void iommu_dev_setup_iSeries(struct pci_dev *dev) { }
-static void iommu_bus_setup_iSeries(struct pci_bus *bus) { }
-
 void iommu_init_early_iSeries(void)
 {
         ppc_md.tce_build = tce_build_iSeries;
         ppc_md.tce_free  = tce_free_iSeries;
 
-        ppc_md.iommu_dev_setup = iommu_dev_setup_iSeries;
-        ppc_md.iommu_bus_setup = iommu_bus_setup_iSeries;
-
-        pci_iommu_init();
+        pci_dma_ops = &dma_iommu_ops;
 }
diff --git a/arch/powerpc/platforms/iseries/ksyms.c b/arch/powerpc/platforms/iseries/ksyms.c
index a2200842f4e5..2430848b98e7 100644
--- a/arch/powerpc/platforms/iseries/ksyms.c
+++ b/arch/powerpc/platforms/iseries/ksyms.c
@@ -19,9 +19,3 @@ EXPORT_SYMBOL(HvCall4);
 EXPORT_SYMBOL(HvCall5);
 EXPORT_SYMBOL(HvCall6);
 EXPORT_SYMBOL(HvCall7);
-
-#ifdef CONFIG_SMP
-EXPORT_SYMBOL(local_get_flags);
-EXPORT_SYMBOL(local_irq_disable);
-EXPORT_SYMBOL(local_irq_restore);
-#endif
diff --git a/arch/powerpc/platforms/iseries/lpevents.c b/arch/powerpc/platforms/iseries/lpevents.c
index e3e929e1b460..c1f4502a3c6a 100644
--- a/arch/powerpc/platforms/iseries/lpevents.c
+++ b/arch/powerpc/platforms/iseries/lpevents.c
@@ -17,6 +17,7 @@
 
 #include <asm/system.h>
 #include <asm/paca.h>
+#include <asm/firmware.h>
 #include <asm/iseries/it_lp_queue.h>
 #include <asm/iseries/hv_lp_event.h>
 #include <asm/iseries/hv_call_event.h>
@@ -318,6 +319,9 @@ static int __init proc_lpevents_init(void)
 {
         struct proc_dir_entry *e;
 
+        if (!firmware_has_feature(FW_FEATURE_ISERIES))
+                return 0;
+
         e = create_proc_entry("iSeries/lpevents", S_IFREG|S_IRUGO, NULL);
         if (e)
                 e->proc_fops = &proc_lpevents_operations;
diff --git a/arch/powerpc/platforms/iseries/mf.c b/arch/powerpc/platforms/iseries/mf.c
index b5737d68d6c4..1ad0e4aaad1a 100644
--- a/arch/powerpc/platforms/iseries/mf.c
+++ b/arch/powerpc/platforms/iseries/mf.c
@@ -38,6 +38,7 @@
 #include <asm/uaccess.h>
 #include <asm/paca.h>
 #include <asm/abs_addr.h>
+#include <asm/firmware.h>
 #include <asm/iseries/vio.h>
 #include <asm/iseries/mf.h>
 #include <asm/iseries/hv_lp_config.h>
@@ -1178,7 +1179,7 @@ static ssize_t proc_mf_change_vmlinux(struct file *file,
                                       const char __user *buf,
                                       size_t count, loff_t *ppos)
 {
-        struct proc_dir_entry *dp = PDE(file->f_dentry->d_inode);
+        struct proc_dir_entry *dp = PDE(file->f_path.dentry->d_inode);
         ssize_t rc;
         dma_addr_t dma_addr;
         char *page;
@@ -1235,6 +1236,9 @@ static int __init mf_proc_init(void)
         char name[2];
         int i;
 
+        if (!firmware_has_feature(FW_FEATURE_ISERIES))
+                return 0;
+
         mf_proc_root = proc_mkdir("iSeries/mf", NULL);
         if (!mf_proc_root)
                 return 1;
diff --git a/arch/powerpc/platforms/iseries/misc.S b/arch/powerpc/platforms/iseries/misc.S
index 7641fc7e550a..2c6ff0fdac98 100644
--- a/arch/powerpc/platforms/iseries/misc.S
+++ b/arch/powerpc/platforms/iseries/misc.S
@@ -19,39 +19,8 @@
 
         .text
 
-/* unsigned long local_save_flags(void) */
-_GLOBAL(local_get_flags)
-        lbz     r3,PACAPROCENABLED(r13)
-        blr
-
-/* unsigned long local_irq_disable(void) */
-_GLOBAL(local_irq_disable)
-        lbz     r3,PACAPROCENABLED(r13)
-        li      r4,0
-        stb     r4,PACAPROCENABLED(r13)
-        blr                     /* Done */
-
-/* void local_irq_restore(unsigned long flags) */
-_GLOBAL(local_irq_restore)
-        lbz     r5,PACAPROCENABLED(r13)
-         /* Check if things are setup the way we want _already_. */
-        cmpw    0,r3,r5
-        beqlr
-        /* are we enabling interrupts? */
-        cmpdi   0,r3,0
-        stb     r3,PACAPROCENABLED(r13)
-        beqlr
-        /* Check pending interrupts */
-        /*   A decrementer, IPI or PMC interrupt may have occurred
-         *   while we were in the hypervisor (which enables) */
-        ld      r4,PACALPPACAPTR(r13)
-        ld      r4,LPPACAANYINT(r4)
-        cmpdi   r4,0
-        beqlr
-
-        /*
-         * Handle pending interrupts in interrupt context
-         */
+/* Handle pending interrupts in interrupt context */
+_GLOBAL(iseries_handle_interrupts)
         li      r0,0x5555
         sc
         blr
diff --git a/arch/powerpc/platforms/iseries/pci.c b/arch/powerpc/platforms/iseries/pci.c
index 4aa165e010d9..4a06d9c34986 100644
--- a/arch/powerpc/platforms/iseries/pci.c
+++ b/arch/powerpc/platforms/iseries/pci.c
@@ -156,53 +156,6 @@ static void pci_Log_Error(char *Error_Text, int Bus, int SubBus,
 }
 
 /*
- * iSeries_pcibios_init
- *
- * Description:
- *   This function checks for all possible system PCI host bridges that connect
- *   PCI buses.  The system hypervisor is queried as to the guest partition
- *   ownership status.  A pci_controller is built for any bus which is partially
- *   owned or fully owned by this guest partition.
- */
-void iSeries_pcibios_init(void)
-{
-        struct pci_controller *phb;
-        struct device_node *root = of_find_node_by_path("/");
-        struct device_node *node = NULL;
-
-        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;
-                const u32 *busp;
-
-                if ((node->type == NULL) || (strcmp(node->type, "pci") != 0))
-                        continue;
-
-                busp = 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;
-        }
-
-        of_node_put(root);
-
-        pci_devs_phb_init();
-}
-
-/*
  * iSeries_pci_final_fixup(void)
  */
 void __init iSeries_pci_final_fixup(void)
@@ -253,7 +206,7 @@ void __init iSeries_pci_final_fixup(void)
                         PCI_DN(node)->pcidev = pdev;
                         allocate_device_bars(pdev);
                         iSeries_Device_Information(pdev, DeviceCount);
-                        iommu_devnode_init_iSeries(node);
+                        iommu_devnode_init_iSeries(pdev, node);
                 } else
                         printk("PCI: Device Tree not found for 0x%016lX\n",
                                         (unsigned long)pdev);
@@ -438,11 +391,7 @@ static inline struct device_node *xlate_iomm_address(
 /*
  * Read MM I/O Instructions for the iSeries
  * On MM I/O error, all ones are returned and iSeries_pci_IoError is cal
- * else, data is returned in big Endian format.
- *
- * iSeries_Read_Byte = Read Byte  ( 8 bit)
- * iSeries_Read_Word = Read Word  (16 bit)
- * iSeries_Read_Long = Read Long  (32 bit)
+ * else, data is returned in Big Endian format.
  */
 static u8 iSeries_Read_Byte(const volatile void __iomem *IoAddress)
 {
@@ -462,14 +411,15 @@ static u8 iSeries_Read_Byte(const volatile void __iomem *IoAddress)
                         num_printed = 0;
                 }
                 if (num_printed++ < 10)
-                        printk(KERN_ERR "iSeries_Read_Byte: invalid access at IO address %p\n", IoAddress);
+                        printk(KERN_ERR "iSeries_Read_Byte: invalid access at IO address %p\n",
+                               IoAddress);
                 return 0xff;
         }
         do {
                 HvCall3Ret16(HvCallPciBarLoad8, &ret, dsa, BarOffset, 0);
         } while (CheckReturnCode("RDB", DevNode, &retry, ret.rc) != 0);
 
-        return (u8)ret.value;
+        return ret.value;
 }
 
 static u16 iSeries_Read_Word(const volatile void __iomem *IoAddress)
@@ -490,7 +440,8 @@ static u16 iSeries_Read_Word(const volatile void __iomem *IoAddress)
                         num_printed = 0;
                 }
                 if (num_printed++ < 10)
-                        printk(KERN_ERR "iSeries_Read_Word: invalid access at IO address %p\n", IoAddress);
+                        printk(KERN_ERR "iSeries_Read_Word: invalid access at IO address %p\n",
+                               IoAddress);
                 return 0xffff;
         }
         do {
@@ -498,7 +449,7 @@ static u16 iSeries_Read_Word(const volatile void __iomem *IoAddress)
                                 BarOffset, 0);
         } while (CheckReturnCode("RDW", DevNode, &retry, ret.rc) != 0);
 
-        return swab16((u16)ret.value);
+        return ret.value;
 }
 
 static u32 iSeries_Read_Long(const volatile void __iomem *IoAddress)
@@ -519,7 +470,8 @@ static u32 iSeries_Read_Long(const volatile void __iomem *IoAddress)
                         num_printed = 0;
                 }
                 if (num_printed++ < 10)
-                        printk(KERN_ERR "iSeries_Read_Long: invalid access at IO address %p\n", IoAddress);
+                        printk(KERN_ERR "iSeries_Read_Long: invalid access at IO address %p\n",
+                               IoAddress);
                 return 0xffffffff;
         }
         do {
@@ -527,15 +479,12 @@ static u32 iSeries_Read_Long(const volatile void __iomem *IoAddress)
                                 BarOffset, 0);
         } while (CheckReturnCode("RDL", DevNode, &retry, ret.rc) != 0);
 
-        return swab32((u32)ret.value);
+        return ret.value;
 }
 
 /*
  * Write MM I/O Instructions for the iSeries
  *
- * iSeries_Write_Byte = Write Byte (8 bit)
- * iSeries_Write_Word = Write Word(16 bit)
- * iSeries_Write_Long = Write Long(32 bit)
  */
 static void iSeries_Write_Byte(u8 data, volatile void __iomem *IoAddress)
 {
@@ -581,11 +530,12 @@ static void iSeries_Write_Word(u16 data, volatile void __iomem *IoAddress)
                         num_printed = 0;
                 }
                 if (num_printed++ < 10)
-                        printk(KERN_ERR "iSeries_Write_Word: invalid access at IO address %p\n", IoAddress);
+                        printk(KERN_ERR "iSeries_Write_Word: invalid access at IO address %p\n",
+                               IoAddress);
                 return;
         }
         do {
-                rc = HvCall4(HvCallPciBarStore16, dsa, BarOffset, swab16(data), 0);
+                rc = HvCall4(HvCallPciBarStore16, dsa, BarOffset, data, 0);
         } while (CheckReturnCode("WWW", DevNode, &retry, rc) != 0);
 }
 
@@ -607,231 +557,221 @@ static void iSeries_Write_Long(u32 data, volatile void __iomem *IoAddress)
                         num_printed = 0;
                 }
                 if (num_printed++ < 10)
-                        printk(KERN_ERR "iSeries_Write_Long: invalid access at IO address %p\n", IoAddress);
+                        printk(KERN_ERR "iSeries_Write_Long: invalid access at IO address %p\n",
+                               IoAddress);
                 return;
         }
         do {
-                rc = HvCall4(HvCallPciBarStore32, dsa, BarOffset, swab32(data), 0);
+                rc = HvCall4(HvCallPciBarStore32, dsa, BarOffset, data, 0);
         } while (CheckReturnCode("WWL", DevNode, &retry, rc) != 0);
 }
 
-extern unsigned char __raw_readb(const volatile void __iomem *addr)
+static u8 iseries_readb(const volatile void __iomem *addr)
 {
-        BUG_ON(firmware_has_feature(FW_FEATURE_ISERIES));
-
-        return *(volatile unsigned char __force *)addr;
+        return iSeries_Read_Byte(addr);
 }
-EXPORT_SYMBOL(__raw_readb);
 
-extern unsigned short __raw_readw(const volatile void __iomem *addr)
+static u16 iseries_readw(const volatile void __iomem *addr)
 {
-        BUG_ON(firmware_has_feature(FW_FEATURE_ISERIES));
-
-        return *(volatile unsigned short __force *)addr;
+        return le16_to_cpu(iSeries_Read_Word(addr));
 }
-EXPORT_SYMBOL(__raw_readw);
 
-extern unsigned int __raw_readl(const volatile void __iomem *addr)
+static u32 iseries_readl(const volatile void __iomem *addr)
 {
-        BUG_ON(firmware_has_feature(FW_FEATURE_ISERIES));
-
-        return *(volatile unsigned int __force *)addr;
+        return le32_to_cpu(iSeries_Read_Long(addr));
 }
-EXPORT_SYMBOL(__raw_readl);
 
-extern unsigned long __raw_readq(const volatile void __iomem *addr)
+static u16 iseries_readw_be(const volatile void __iomem *addr)
 {
-        BUG_ON(firmware_has_feature(FW_FEATURE_ISERIES));
-
-        return *(volatile unsigned long __force *)addr;
+        return iSeries_Read_Word(addr);
 }
-EXPORT_SYMBOL(__raw_readq);
 
-extern void __raw_writeb(unsigned char v, volatile void __iomem *addr)
+static u32 iseries_readl_be(const volatile void __iomem *addr)
 {
-        BUG_ON(firmware_has_feature(FW_FEATURE_ISERIES));
-
-        *(volatile unsigned char __force *)addr = v;
+        return iSeries_Read_Long(addr);
 }
-EXPORT_SYMBOL(__raw_writeb);
 
-extern void __raw_writew(unsigned short v, volatile void __iomem *addr)
+static void iseries_writeb(u8 data, volatile void __iomem *addr)
 {
-        BUG_ON(firmware_has_feature(FW_FEATURE_ISERIES));
-
-        *(volatile unsigned short __force *)addr = v;
+        iSeries_Write_Byte(data, addr);
 }
-EXPORT_SYMBOL(__raw_writew);
 
-extern void __raw_writel(unsigned int v, volatile void __iomem *addr)
+static void iseries_writew(u16 data, volatile void __iomem *addr)
 {
-        BUG_ON(firmware_has_feature(FW_FEATURE_ISERIES));
-
-        *(volatile unsigned int __force *)addr = v;
+        iSeries_Write_Word(cpu_to_le16(data), addr);
 }
-EXPORT_SYMBOL(__raw_writel);
 
-extern void __raw_writeq(unsigned long v, volatile void __iomem *addr)
+static void iseries_writel(u32 data, volatile void __iomem *addr)
 {
-        BUG_ON(firmware_has_feature(FW_FEATURE_ISERIES));
-
-        *(volatile unsigned long __force *)addr = v;
+        iSeries_Write_Long(cpu_to_le32(data), addr);
 }
-EXPORT_SYMBOL(__raw_writeq);
 
-int in_8(const volatile unsigned char __iomem *addr)
+static void iseries_writew_be(u16 data, volatile void __iomem *addr)
 {
-        if (firmware_has_feature(FW_FEATURE_ISERIES))
-                return iSeries_Read_Byte(addr);
-        return __in_8(addr);
+        iSeries_Write_Word(data, addr);
 }
-EXPORT_SYMBOL(in_8);
 
-void out_8(volatile unsigned char __iomem *addr, int val)
+static void iseries_writel_be(u32 data, volatile void __iomem *addr)
 {
-        if (firmware_has_feature(FW_FEATURE_ISERIES))
-                iSeries_Write_Byte(val, addr);
-        else
-                __out_8(addr, val);
+        iSeries_Write_Long(data, addr);
 }
-EXPORT_SYMBOL(out_8);
 
-int in_le16(const volatile unsigned short __iomem *addr)
+static void iseries_readsb(const volatile void __iomem *addr, void *buf,
+                           unsigned long count)
 {
-        if (firmware_has_feature(FW_FEATURE_ISERIES))
-                return iSeries_Read_Word(addr);
-        return __in_le16(addr);
+        u8 *dst = buf;
+        while(count-- > 0)
+                *(dst++) = iSeries_Read_Byte(addr);
 }
-EXPORT_SYMBOL(in_le16);
 
-int in_be16(const volatile unsigned short __iomem *addr)
+static void iseries_readsw(const volatile void __iomem *addr, void *buf,
+                           unsigned long count)
 {
-        BUG_ON(firmware_has_feature(FW_FEATURE_ISERIES));
-
-        return __in_be16(addr);
+        u16 *dst = buf;
+        while(count-- > 0)
+                *(dst++) = iSeries_Read_Word(addr);
 }
-EXPORT_SYMBOL(in_be16);
 
-void out_le16(volatile unsigned short __iomem *addr, int val)
+static void iseries_readsl(const volatile void __iomem *addr, void *buf,
+                           unsigned long count)
 {
-        if (firmware_has_feature(FW_FEATURE_ISERIES))
-                iSeries_Write_Word(val, addr);
-        else
-                __out_le16(addr, val);
+        u32 *dst = buf;
+        while(count-- > 0)
+                *(dst++) = iSeries_Read_Long(addr);
 }
-EXPORT_SYMBOL(out_le16);
 
-void out_be16(volatile unsigned short __iomem *addr, int val)
+static void iseries_writesb(volatile void __iomem *addr, const void *buf,
+                            unsigned long count)
 {
-        BUG_ON(firmware_has_feature(FW_FEATURE_ISERIES));
-
-        __out_be16(addr, val);
+        const u8 *src = buf;
+        while(count-- > 0)
+                iSeries_Write_Byte(*(src++), addr);
 }
-EXPORT_SYMBOL(out_be16);
 
-unsigned in_le32(const volatile unsigned __iomem *addr)
+static void iseries_writesw(volatile void __iomem *addr, const void *buf,
+                            unsigned long count)
 {
-        if (firmware_has_feature(FW_FEATURE_ISERIES))
-                return iSeries_Read_Long(addr);
-        return __in_le32(addr);
+        const u16 *src = buf;
+        while(count-- > 0)
+                iSeries_Write_Word(*(src++), addr);
 }
-EXPORT_SYMBOL(in_le32);
 
-unsigned in_be32(const volatile unsigned __iomem *addr)
+static void iseries_writesl(volatile void __iomem *addr, const void *buf,
+                            unsigned long count)
 {
-        BUG_ON(firmware_has_feature(FW_FEATURE_ISERIES));
-
-        return __in_be32(addr);
+        const u32 *src = buf;
+        while(count-- > 0)
+                iSeries_Write_Long(*(src++), addr);
 }
-EXPORT_SYMBOL(in_be32);
 
-void out_le32(volatile unsigned __iomem *addr, int val)
+static void iseries_memset_io(volatile void __iomem *addr, int c,
+                              unsigned long n)
 {
-        if (firmware_has_feature(FW_FEATURE_ISERIES))
-                iSeries_Write_Long(val, addr);
-        else
-                __out_le32(addr, val);
-}
-EXPORT_SYMBOL(out_le32);
+        volatile char __iomem *d = addr;
 
-void out_be32(volatile unsigned __iomem *addr, int val)
-{
-        BUG_ON(firmware_has_feature(FW_FEATURE_ISERIES));
-
-        __out_be32(addr, val);
+        while (n-- > 0)
+                iSeries_Write_Byte(c, d++);
 }
-EXPORT_SYMBOL(out_be32);
 
-unsigned long in_le64(const volatile unsigned long __iomem *addr)
+static void iseries_memcpy_fromio(void *dest, const volatile void __iomem *src,
+                                  unsigned long n)
 {
-        BUG_ON(firmware_has_feature(FW_FEATURE_ISERIES));
+        char *d = dest;
+        const volatile char __iomem *s = src;
 
-        return __in_le64(addr);
+        while (n-- > 0)
+                *d++ = iSeries_Read_Byte(s++);
 }
-EXPORT_SYMBOL(in_le64);
 
-unsigned long in_be64(const volatile unsigned long __iomem *addr)
+static void iseries_memcpy_toio(volatile void __iomem *dest, const void *src,
+                                unsigned long n)
 {
-        BUG_ON(firmware_has_feature(FW_FEATURE_ISERIES));
+        const char *s = src;
+        volatile char __iomem *d = dest;
 
-        return __in_be64(addr);
+        while (n-- > 0)
+                iSeries_Write_Byte(*s++, d++);
 }
-EXPORT_SYMBOL(in_be64);
-
-void out_le64(volatile unsigned long __iomem *addr, unsigned long val)
-{
-        BUG_ON(firmware_has_feature(FW_FEATURE_ISERIES));
 
-        __out_le64(addr, val);
-}
-EXPORT_SYMBOL(out_le64);
+/* We only set MMIO ops. The default PIO ops will be default
+ * to the MMIO ops + pci_io_base which is 0 on iSeries as
+ * expected so both should work.
+ *
+ * Note that we don't implement the readq/writeq versions as
+ * I don't know of an HV call for doing so. Thus, the default
+ * operation will be used instead, which will fault a the value
+ * return by iSeries for MMIO addresses always hits a non mapped
+ * area. This is as good as the BUG() we used to have there.
+ */
+static struct ppc_pci_io __initdata iseries_pci_io = {
+        .readb = iseries_readb,
+        .readw = iseries_readw,
+        .readl = iseries_readl,
+        .readw_be = iseries_readw_be,
+        .readl_be = iseries_readl_be,
+        .writeb = iseries_writeb,
+        .writew = iseries_writew,
+        .writel = iseries_writel,
+        .writew_be = iseries_writew_be,
+        .writel_be = iseries_writel_be,
+        .readsb = iseries_readsb,
+        .readsw = iseries_readsw,
+        .readsl = iseries_readsl,
+        .writesb = iseries_writesb,
+        .writesw = iseries_writesw,
+        .writesl = iseries_writesl,
+        .memset_io = iseries_memset_io,
+        .memcpy_fromio = iseries_memcpy_fromio,
+        .memcpy_toio = iseries_memcpy_toio,
+};
 
-void out_be64(volatile unsigned long __iomem *addr, unsigned long val)
+/*
+ * iSeries_pcibios_init
+ *
+ * Description:
+ *   This function checks for all possible system PCI host bridges that connect
+ *   PCI buses.  The system hypervisor is queried as to the guest partition
+ *   ownership status.  A pci_controller is built for any bus which is partially
+ *   owned or fully owned by this guest partition.
+ */
+void __init iSeries_pcibios_init(void)
 {
-        BUG_ON(firmware_has_feature(FW_FEATURE_ISERIES));
+        struct pci_controller *phb;
+        struct device_node *root = of_find_node_by_path("/");
+        struct device_node *node = NULL;
 
-        __out_be64(addr, val);
-}
-EXPORT_SYMBOL(out_be64);
+        /* Install IO hooks */
+        ppc_pci_io = iseries_pci_io;
 
-void memset_io(volatile void __iomem *addr, int c, unsigned long n)
-{
-        if (firmware_has_feature(FW_FEATURE_ISERIES)) {
-                volatile char __iomem *d = addr;
+        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;
+                const u32 *busp;
 
-                while (n-- > 0) {
-                        iSeries_Write_Byte(c, d++);
-                }
-        } else
-                eeh_memset_io(addr, c, n);
-}
-EXPORT_SYMBOL(memset_io);
+                if ((node->type == NULL) || (strcmp(node->type, "pci") != 0))
+                        continue;
 
-void memcpy_fromio(void *dest, const volatile void __iomem *src,
-                                 unsigned long n)
-{
-        if (firmware_has_feature(FW_FEATURE_ISERIES)) {
-                char *d = dest;
-                const volatile char __iomem *s = src;
+                busp = 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;
 
-                while (n-- > 0) {
-                        *d++ = iSeries_Read_Byte(s++);
-                }
-        } else
-                eeh_memcpy_fromio(dest, src, n);
-}
-EXPORT_SYMBOL(memcpy_fromio);
+                phb->pci_mem_offset = phb->local_number = bus;
+                phb->first_busno = bus;
+                phb->last_busno = bus;
+                phb->ops = &iSeries_pci_ops;
+        }
 
-void memcpy_toio(volatile void __iomem *dest, const void *src, unsigned long n)
-{
-        if (firmware_has_feature(FW_FEATURE_ISERIES)) {
-                const char *s = src;
-                volatile char __iomem *d = dest;
+        of_node_put(root);
 
-                while (n-- > 0) {
-                        iSeries_Write_Byte(*s++, d++);
-                }
-        } else
-                eeh_memcpy_toio(dest, src, n);
+        pci_devs_phb_init();
 }
-EXPORT_SYMBOL(memcpy_toio);
+
diff --git a/arch/powerpc/platforms/iseries/proc.c b/arch/powerpc/platforms/iseries/proc.c
index c241413629ac..b54e37101e69 100644
--- a/arch/powerpc/platforms/iseries/proc.c
+++ b/arch/powerpc/platforms/iseries/proc.c
@@ -24,6 +24,7 @@
 #include <asm/processor.h>
 #include <asm/time.h>
 #include <asm/lppaca.h>
+#include <asm/firmware.h>
 #include <asm/iseries/hv_call_xm.h>
 
 #include "processor_vpd.h"
@@ -31,7 +32,12 @@
 
 static int __init iseries_proc_create(void)
 {
-        struct proc_dir_entry *e = proc_mkdir("iSeries", 0);
+        struct proc_dir_entry *e;
+
+        if (!firmware_has_feature(FW_FEATURE_ISERIES))
+                return 0;
+
+        e = proc_mkdir("iSeries", 0);
         if (!e)
                 return 1;
 
@@ -106,6 +112,9 @@ static int __init iseries_proc_init(void)
 {
         struct proc_dir_entry *e;
 
+        if (!firmware_has_feature(FW_FEATURE_ISERIES))
+                return 0;
+
         e = create_proc_entry("iSeries/titanTod", S_IFREG|S_IRUGO, NULL);
         if (e)
                 e->proc_fops = &proc_titantod_operations;
diff --git a/arch/powerpc/platforms/iseries/setup.c b/arch/powerpc/platforms/iseries/setup.c
index 6f73469fd3b0..cce7e309340c 100644
--- a/arch/powerpc/platforms/iseries/setup.c
+++ b/arch/powerpc/platforms/iseries/setup.c
@@ -21,7 +21,6 @@
 #include <linux/smp.h>
 #include <linux/param.h>
 #include <linux/string.h>
-#include <linux/initrd.h>
 #include <linux/seq_file.h>
 #include <linux/kdev_t.h>
 #include <linux/major.h>
@@ -80,8 +79,6 @@ extern void iSeries_pci_final_fixup(void);
 static void iSeries_pci_final_fixup(void) { }
 #endif
 
-extern int rd_size;             /* Defined in drivers/block/rd.c */
-
 extern unsigned long iSeries_recal_tb;
 extern unsigned long iSeries_recal_titan;
 
@@ -295,24 +292,6 @@ static void __init iSeries_init_early(void)
 {
         DBG(" -> iSeries_init_early()\n");
 
-#if defined(CONFIG_BLK_DEV_INITRD)
-        /*
-         * If the init RAM disk has been configured and there is
-         * a non-zero starting address for it, set it up
-         */
-        if (naca.xRamDisk) {
-                initrd_start = (unsigned long)__va(naca.xRamDisk);
-                initrd_end = initrd_start + naca.xRamDiskSize * HW_PAGE_SIZE;
-                initrd_below_start_ok = 1;      // ramdisk in kernel space
-                ROOT_DEV = Root_RAM0;
-                if (((rd_size * 1024) / HW_PAGE_SIZE) < naca.xRamDiskSize)
-                        rd_size = (naca.xRamDiskSize * HW_PAGE_SIZE) / 1024;
-        } else
-#endif /* CONFIG_BLK_DEV_INITRD */
-        {
-            /* ROOT_DEV = MKDEV(VIODASD_MAJOR, 1); */
-        }
-
         iSeries_recal_tb = get_tb();
         iSeries_recal_titan = HvCallXm_loadTod();
 
@@ -331,17 +310,6 @@ static void __init iSeries_init_early(void)
 
         mf_init();
 
-        /* If we were passed an initrd, set the ROOT_DEV properly if the values
-         * look sensible. If not, clear initrd reference.
-         */
-#ifdef CONFIG_BLK_DEV_INITRD
-        if (initrd_start >= KERNELBASE && initrd_end >= KERNELBASE &&
-            initrd_end > initrd_start)
-                ROOT_DEV = Root_RAM0;
-        else
-                initrd_start = initrd_end = 0;
-#endif /* CONFIG_BLK_DEV_INITRD */
-
         DBG(" <- iSeries_init_early()\n");
 }
 
@@ -559,7 +527,8 @@ static void __init iSeries_fixup_klimit(void)
 static int __init iSeries_src_init(void)
 {
         /* clear the progress line */
-        ppc_md.progress(" ", 0xffff);
+        if (firmware_has_feature(FW_FEATURE_ISERIES))
+                ppc_md.progress(" ", 0xffff);
         return 0;
 }
 
@@ -649,6 +618,16 @@ static void iseries_dedicated_idle(void)
 void __init iSeries_init_IRQ(void) { }
 #endif
 
+static void __iomem *iseries_ioremap(phys_addr_t address, unsigned long size,
+                                     unsigned long flags)
+{
+        return (void __iomem *)address;
+}
+
+static void iseries_iounmap(volatile void __iomem *token)
+{
+}
+
 /*
  * iSeries has no legacy IO, anything calling this function has to
  * fail or bad things will happen
@@ -665,6 +644,8 @@ static int __init iseries_probe(void)
                 return 0;
 
         hpte_init_iSeries();
+        /* iSeries does not support 16M pages */
+        cur_cpu_spec->cpu_features &= ~CPU_FTR_16M_PAGE;
 
         return 1;
 }
@@ -687,6 +668,8 @@ define_machine(iseries) {
         .progress       = iSeries_progress,
         .probe          = iseries_probe,
         .check_legacy_ioport    = iseries_check_legacy_ioport,
+        .ioremap        = iseries_ioremap,
+        .iounmap        = iseries_iounmap,
         /* XXX Implement enable_pmcs for iSeries */
 };
 
@@ -697,7 +680,7 @@ void * __init iSeries_early_setup(void)
         /* Identify CPU type. This is done again by the common code later
          * on but calling this function multiple times is fine.
          */
-        identify_cpu(0);
+        identify_cpu(0, mfspr(SPRN_PVR));
 
         powerpc_firmware_features |= FW_FEATURE_ISERIES;
         powerpc_firmware_features |= FW_FEATURE_LPAR;
diff --git a/arch/powerpc/platforms/iseries/viopath.c b/arch/powerpc/platforms/iseries/viopath.c
index 04e07e5da0c1..a6799ed34a66 100644
--- a/arch/powerpc/platforms/iseries/viopath.c
+++ b/arch/powerpc/platforms/iseries/viopath.c
@@ -42,6 +42,7 @@
 #include <asm/system.h>
 #include <asm/uaccess.h>
 #include <asm/prom.h>
+#include <asm/firmware.h>
 #include <asm/iseries/hv_types.h>
 #include <asm/iseries/hv_lp_event.h>
 #include <asm/iseries/hv_lp_config.h>
@@ -119,10 +120,9 @@ static int proc_viopath_show(struct seq_file *m, void *v)
         struct device_node *node;
         const char *sysid;
 
-        buf = kmalloc(HW_PAGE_SIZE, GFP_KERNEL);
+        buf = kzalloc(HW_PAGE_SIZE, GFP_KERNEL);
         if (!buf)
                 return 0;
-        memset(buf, 0, HW_PAGE_SIZE);
 
         handle = dma_map_single(iSeries_vio_dev, buf, HW_PAGE_SIZE,
                                 DMA_FROM_DEVICE);
@@ -184,6 +184,9 @@ static int __init vio_proc_init(void)
 {
         struct proc_dir_entry *e;
 
+        if (!firmware_has_feature(FW_FEATURE_ISERIES))
+                return 0;
+
         e = create_proc_entry("iSeries/config", 0, NULL);
         if (e)
                 e->proc_fops = &proc_viopath_operations;
diff --git a/arch/powerpc/platforms/maple/maple.h b/arch/powerpc/platforms/maple/maple.h
index 0657c579b840..c6911ddc479f 100644
--- a/arch/powerpc/platforms/maple/maple.h
+++ b/arch/powerpc/platforms/maple/maple.h
@@ -8,5 +8,5 @@ extern void maple_get_rtc_time(struct rtc_time *tm);
 extern unsigned long maple_get_boot_time(void);
 extern void maple_calibrate_decr(void);
 extern void maple_pci_init(void);
-extern void maple_pcibios_fixup(void);
+extern void maple_pci_irq_fixup(struct pci_dev *dev);
 extern int maple_pci_get_legacy_ide_irq(struct pci_dev *dev, int channel);
diff --git a/arch/powerpc/platforms/maple/pci.c b/arch/powerpc/platforms/maple/pci.c
index 63b4d1bff359..3f6a69f67195 100644
--- a/arch/powerpc/platforms/maple/pci.c
+++ b/arch/powerpc/platforms/maple/pci.c
@@ -502,38 +502,29 @@ static int __init add_bridge(struct device_node *dev)
 }
 
 
-void __init maple_pcibios_fixup(void)
+void __devinit maple_pci_irq_fixup(struct pci_dev *dev)
 {
-        struct pci_dev *dev = NULL;
-
-        DBG(" -> maple_pcibios_fixup\n");
-
-        for_each_pci_dev(dev) {
-                /* Fixup IRQ for PCIe host */
-                if (u4_pcie != NULL && dev->bus->number == 0 &&
-                    pci_bus_to_host(dev->bus) == u4_pcie) {
-                        printk(KERN_DEBUG "Fixup U4 PCIe IRQ\n");
-                        dev->irq = irq_create_mapping(NULL, 1);
-                        if (dev->irq != NO_IRQ)
-                                set_irq_type(dev->irq, IRQ_TYPE_LEVEL_LOW);
-                        continue;
-                }
-
-                /* Hide AMD8111 IDE interrupt when in legacy mode so
-                 * the driver calls pci_get_legacy_ide_irq()
-                 */
-                if (dev->vendor == PCI_VENDOR_ID_AMD &&
-                    dev->device == PCI_DEVICE_ID_AMD_8111_IDE &&
-                    (dev->class & 5) != 5) {
-                        dev->irq = NO_IRQ;
-                        continue;
-                }
+        DBG(" -> maple_pci_irq_fixup\n");
+
+        /* Fixup IRQ for PCIe host */
+        if (u4_pcie != NULL && dev->bus->number == 0 &&
+            pci_bus_to_host(dev->bus) == u4_pcie) {
+                printk(KERN_DEBUG "Fixup U4 PCIe IRQ\n");
+                dev->irq = irq_create_mapping(NULL, 1);
+                if (dev->irq != NO_IRQ)
+                        set_irq_type(dev->irq, IRQ_TYPE_LEVEL_LOW);
+        }
 
-                /* For all others, map the interrupt from the device-tree */
-                pci_read_irq_line(dev);
+        /* Hide AMD8111 IDE interrupt when in legacy mode so
+         * the driver calls pci_get_legacy_ide_irq()
+         */
+        if (dev->vendor == PCI_VENDOR_ID_AMD &&
+            dev->device == PCI_DEVICE_ID_AMD_8111_IDE &&
+            (dev->class & 5) != 5) {
+                dev->irq = NO_IRQ;
         }
 
-        DBG(" <- maple_pcibios_fixup\n");
+        DBG(" <- maple_pci_irq_fixup\n");
 }
 
 static void __init maple_fixup_phb_resources(void)
@@ -571,7 +562,7 @@ void __init maple_pci_init(void)
         for (np = NULL; (np = of_get_next_child(root, np)) != NULL;) {
                 if (np->name == NULL)
                         continue;
-                if (strcmp(np->name, "pci") == 0) {
+                if (!strcmp(np->name, "pci") || !strcmp(np->name, "pcie")) {
                         if (add_bridge(np) == 0)
                                 of_node_get(np);
                 }
diff --git a/arch/powerpc/platforms/maple/setup.c b/arch/powerpc/platforms/maple/setup.c
index fe6b9bff61b9..50855d4fd5a0 100644
--- a/arch/powerpc/platforms/maple/setup.c
+++ b/arch/powerpc/platforms/maple/setup.c
@@ -60,6 +60,7 @@
 #include <asm/of_device.h>
 #include <asm/lmb.h>
 #include <asm/mpic.h>
+#include <asm/rtas.h>
 #include <asm/udbg.h>
 
 #include "maple.h"
@@ -166,6 +167,16 @@ struct smp_ops_t maple_smp_ops = {
 };
 #endif /* CONFIG_SMP */
 
+static void __init maple_use_rtas_reboot_and_halt_if_present(void)
+{
+        if (rtas_service_present("system-reboot") &&
+            rtas_service_present("power-off")) {
+                ppc_md.restart = rtas_restart;
+                ppc_md.power_off = rtas_power_off;
+                ppc_md.halt = rtas_halt;
+        }
+}
+
 void __init maple_setup_arch(void)
 {
         /* init to some ~sane value until calibrate_delay() runs */
@@ -181,6 +192,7 @@ void __init maple_setup_arch(void)
 #ifdef CONFIG_DUMMY_CONSOLE
         conswitchp = &dummy_con;
 #endif
+        maple_use_rtas_reboot_and_halt_if_present();
 
         printk(KERN_DEBUG "Using native/NAP idle loop\n");
 }
@@ -242,7 +254,6 @@ static void __init maple_init_IRQ(void)
                 printk(KERN_DEBUG "OpenPIC addr: %lx, has ISUs: %d\n",
                        openpic_addr, has_isus);
         }
-        of_node_put(root);
 
         BUG_ON(openpic_addr == 0);
 
@@ -312,7 +323,7 @@ define_machine(maple_md) {
         .setup_arch             = maple_setup_arch,
         .init_early             = maple_init_early,
         .init_IRQ               = maple_init_IRQ,
-        .pcibios_fixup          = maple_pcibios_fixup,
+        .pci_irq_fixup          = maple_pci_irq_fixup,
         .pci_get_legacy_ide_irq = maple_pci_get_legacy_ide_irq,
         .restart                = maple_restart,
         .power_off              = maple_power_off,
diff --git a/arch/powerpc/platforms/pasemi/pasemi.h b/arch/powerpc/platforms/pasemi/pasemi.h
index fd71d72736b2..51c2a2397ecf 100644
--- a/arch/powerpc/platforms/pasemi/pasemi.h
+++ b/arch/powerpc/platforms/pasemi/pasemi.h
@@ -3,6 +3,5 @@
 
 extern unsigned long pas_get_boot_time(void);
 extern void pas_pci_init(void);
-extern void pas_pcibios_fixup(void);
 
 #endif /* _PASEMI_PASEMI_H */
diff --git a/arch/powerpc/platforms/pasemi/pci.c b/arch/powerpc/platforms/pasemi/pci.c
index 39020c1fa13d..faa618e04047 100644
--- a/arch/powerpc/platforms/pasemi/pci.c
+++ b/arch/powerpc/platforms/pasemi/pci.c
@@ -148,14 +148,6 @@ static int __init add_bridge(struct device_node *dev)
 }
 
 
-void __init pas_pcibios_fixup(void)
-{
-        struct pci_dev *dev = NULL;
-
-        for_each_pci_dev(dev)
-                pci_read_irq_line(dev);
-}
-
 static void __init pas_fixup_phb_resources(void)
 {
         struct pci_controller *hose, *tmp;
diff --git a/arch/powerpc/platforms/pasemi/setup.c b/arch/powerpc/platforms/pasemi/setup.c
index 106896c3b60a..bea7d1bb1a3b 100644
--- a/arch/powerpc/platforms/pasemi/setup.c
+++ b/arch/powerpc/platforms/pasemi/setup.c
@@ -26,6 +26,7 @@
 #include <linux/kernel.h>
 #include <linux/delay.h>
 #include <linux/console.h>
+#include <linux/pci.h>
 
 #include <asm/prom.h>
 #include <asm/system.h>
@@ -71,6 +72,9 @@ void __init pas_setup_arch(void)
         /* Setup SMP callback */
         smp_ops = &pas_smp_ops;
 #endif
+        /* no iommu yet */
+        pci_dma_ops = &dma_direct_ops;
+
         /* Lookup PCI hosts */
         pas_pci_init();
 
@@ -81,17 +85,6 @@ void __init pas_setup_arch(void)
         printk(KERN_DEBUG "Using default idle loop\n");
 }
 
-static void iommu_dev_setup_null(struct pci_dev *dev) { }
-static void iommu_bus_setup_null(struct pci_bus *bus) { }
-
-static void __init pas_init_early(void)
-{
-        /* No iommu code yet */
-        ppc_md.iommu_dev_setup = iommu_dev_setup_null;
-        ppc_md.iommu_bus_setup = iommu_bus_setup_null;
-        pci_direct_iommu_init();
-}
-
 /* No legacy IO on our parts */
 static int pas_check_legacy_ioport(unsigned int baseport)
 {
@@ -136,7 +129,6 @@ static __init void pas_init_IRQ(void)
         }
         openpic_addr = of_read_number(opprop, naddr);
         printk(KERN_DEBUG "OpenPIC addr: %lx\n", openpic_addr);
-        of_node_put(root);
 
         mpic = mpic_alloc(mpic_node, openpic_addr, MPIC_PRIMARY, 0, 0,
                           " PAS-OPIC  ");
@@ -173,10 +165,8 @@ define_machine(pas) {
         .name                   = "PA Semi PA6T-1682M",
         .probe                  = pas_probe,
         .setup_arch             = pas_setup_arch,
-        .init_early             = pas_init_early,
         .init_IRQ               = pas_init_IRQ,
         .get_irq                = mpic_get_irq,
-        .pcibios_fixup          = pas_pcibios_fixup,
         .restart                = pas_restart,
         .power_off              = pas_power_off,
         .halt                   = pas_halt,
diff --git a/arch/powerpc/platforms/powermac/backlight.c b/arch/powerpc/platforms/powermac/backlight.c
index afa593a8544a..c3a89414ddc0 100644
--- a/arch/powerpc/platforms/powermac/backlight.c
+++ b/arch/powerpc/platforms/powermac/backlight.c
@@ -18,11 +18,11 @@
 
 #define OLD_BACKLIGHT_MAX 15
 
-static void pmac_backlight_key_worker(void *data);
-static void pmac_backlight_set_legacy_worker(void *data);
+static void pmac_backlight_key_worker(struct work_struct *work);
+static void pmac_backlight_set_legacy_worker(struct work_struct *work);
 
-static DECLARE_WORK(pmac_backlight_key_work, pmac_backlight_key_worker, NULL);
-static DECLARE_WORK(pmac_backlight_set_legacy_work, pmac_backlight_set_legacy_worker, NULL);
+static DECLARE_WORK(pmac_backlight_key_work, pmac_backlight_key_worker);
+static DECLARE_WORK(pmac_backlight_set_legacy_work, pmac_backlight_set_legacy_worker);
 
 /* Although these variables are used in interrupt context, it makes no sense to
  * protect them. No user is able to produce enough key events per second and
@@ -94,7 +94,7 @@ int pmac_backlight_curve_lookup(struct fb_info *info, int value)
         return level;
 }
 
-static void pmac_backlight_key_worker(void *data)
+static void pmac_backlight_key_worker(struct work_struct *work)
 {
         if (atomic_read(&kernel_backlight_disabled))
                 return;
@@ -166,7 +166,7 @@ static int __pmac_backlight_set_legacy_brightness(int brightness)
         return error;
 }
 
-static void pmac_backlight_set_legacy_worker(void *data)
+static void pmac_backlight_set_legacy_worker(struct work_struct *work)
 {
         if (atomic_read(&kernel_backlight_disabled))
                 return;
diff --git a/arch/powerpc/platforms/powermac/feature.c b/arch/powerpc/platforms/powermac/feature.c
index e49621be6640..c29a6a064d22 100644
--- a/arch/powerpc/platforms/powermac/feature.c
+++ b/arch/powerpc/platforms/powermac/feature.c
@@ -486,10 +486,6 @@ static long heathrow_sound_enable(struct device_node *node, long param,
 
 static u32 save_fcr[6];
 static u32 save_mbcr;
-static u32 save_gpio_levels[2];
-static u8 save_gpio_extint[KEYLARGO_GPIO_EXTINT_CNT];
-static u8 save_gpio_normal[KEYLARGO_GPIO_CNT];
-static u32 save_unin_clock_ctl;
 static struct dbdma_regs save_dbdma[13];
 static struct dbdma_regs save_alt_dbdma[13];
 
@@ -1548,6 +1544,10 @@ void g5_phy_disable_cpu1(void)
 
 
 #ifdef CONFIG_PM
+static u32 save_gpio_levels[2];
+static u8 save_gpio_extint[KEYLARGO_GPIO_EXTINT_CNT];
+static u8 save_gpio_normal[KEYLARGO_GPIO_CNT];
+static u32 save_unin_clock_ctl;
 
 static void keylargo_shutdown(struct macio_chip *macio, int sleep_mode)
 {
diff --git a/arch/powerpc/platforms/powermac/pci.c b/arch/powerpc/platforms/powermac/pci.c
index 9923adc5248e..f42475b27c15 100644
--- a/arch/powerpc/platforms/powermac/pci.c
+++ b/arch/powerpc/platforms/powermac/pci.c
@@ -48,7 +48,6 @@ static struct pci_controller *u3_ht;
 static int has_second_ohare;
 #endif /* CONFIG_PPC64 */
 
-extern u8 pci_cache_line_size;
 extern int pcibios_assign_bus_offset;
 
 struct device_node *k2_skiplist[2];
@@ -985,30 +984,23 @@ static int __init add_bridge(struct device_node *dev)
         return 0;
 }
 
-void __init pmac_pcibios_fixup(void)
+void __devinit pmac_pci_irq_fixup(struct pci_dev *dev)
 {
-        struct pci_dev* dev = NULL;
-
-        for_each_pci_dev(dev) {
-                /* Read interrupt from the device-tree */
-                pci_read_irq_line(dev);
-
 #ifdef CONFIG_PPC32
-                /* Fixup interrupt for the modem/ethernet combo controller.
-                 * on machines with a second ohare chip.
-                 * The number in the device tree (27) is bogus (correct for
-                 * the ethernet-only board but not the combo ethernet/modem
-                 * board). The real interrupt is 28 on the second controller
-                 * -> 28+32 = 60.
-                 */
-                if (has_second_ohare &&
-                    dev->vendor == PCI_VENDOR_ID_DEC &&
-                    dev->device == PCI_DEVICE_ID_DEC_TULIP_PLUS) {
-                        dev->irq = irq_create_mapping(NULL, 60);
-                        set_irq_type(dev->irq, IRQ_TYPE_LEVEL_LOW);
-                }
-#endif /* CONFIG_PPC32 */
+        /* Fixup interrupt for the modem/ethernet combo controller.
+         * on machines with a second ohare chip.
+         * The number in the device tree (27) is bogus (correct for
+         * the ethernet-only board but not the combo ethernet/modem
+         * board). The real interrupt is 28 on the second controller
+         * -> 28+32 = 60.
+         */
+        if (has_second_ohare &&
+            dev->vendor == PCI_VENDOR_ID_DEC &&
+            dev->device == PCI_DEVICE_ID_DEC_TULIP_PLUS) {
+                dev->irq = irq_create_mapping(NULL, 60);
+                set_irq_type(dev->irq, IRQ_TYPE_LEVEL_LOW);
         }
+#endif /* CONFIG_PPC32 */
 }
 
 #ifdef CONFIG_PPC64
diff --git a/arch/powerpc/platforms/powermac/pmac.h b/arch/powerpc/platforms/powermac/pmac.h
index 94e7b24b840b..6e090a7dea83 100644
--- a/arch/powerpc/platforms/powermac/pmac.h
+++ b/arch/powerpc/platforms/powermac/pmac.h
@@ -20,7 +20,7 @@ extern void pmac_get_rtc_time(struct rtc_time *);
 extern int pmac_set_rtc_time(struct rtc_time *);
 extern void pmac_read_rtc_time(void);
 extern void pmac_calibrate_decr(void);
-extern void pmac_pcibios_fixup(void);
+extern void pmac_pci_irq_fixup(struct pci_dev *);
 extern void pmac_pci_init(void);
 extern unsigned long pmac_ide_get_base(int index);
 extern void pmac_ide_init_hwif_ports(hw_regs_t *hw,
diff --git a/arch/powerpc/platforms/powermac/setup.c b/arch/powerpc/platforms/powermac/setup.c
index 824a618396ab..d949e9df41ef 100644
--- a/arch/powerpc/platforms/powermac/setup.c
+++ b/arch/powerpc/platforms/powermac/setup.c
@@ -70,6 +70,7 @@
 #include <asm/pmac_feature.h>
 #include <asm/time.h>
 #include <asm/of_device.h>
+#include <asm/of_platform.h>
 #include <asm/mmu_context.h>
 #include <asm/iommu.h>
 #include <asm/smu.h>
@@ -361,7 +362,7 @@ char *bootdevice;
 void *boot_host;
 int boot_target;
 int boot_part;
-extern dev_t boot_dev;
+static dev_t boot_dev;
 
 #ifdef CONFIG_SCSI
 void __init note_scsi_host(struct device_node *node, void *host)
@@ -676,8 +677,6 @@ static int __init pmac_probe(void)
 
 #ifdef CONFIG_PPC32
         /* isa_io_base gets set in pmac_pci_init */
-        isa_mem_base = PMAC_ISA_MEM_BASE;
-        pci_dram_offset = PMAC_PCI_DRAM_OFFSET;
         ISA_DMA_THRESHOLD = ~0L;
         DMA_MODE_READ = 1;
         DMA_MODE_WRITE = 2;
@@ -727,7 +726,7 @@ define_machine(powermac) {
         .show_cpuinfo           = pmac_show_cpuinfo,
         .init_IRQ               = pmac_pic_init,
         .get_irq                = NULL, /* changed later */
-        .pcibios_fixup          = pmac_pcibios_fixup,
+        .pci_irq_fixup          = pmac_pci_irq_fixup,
         .restart                = pmac_restart,
         .power_off              = pmac_power_off,
         .halt                   = pmac_halt,
diff --git a/arch/powerpc/platforms/ps3/Kconfig b/arch/powerpc/platforms/ps3/Kconfig
new file mode 100644
index 000000000000..de52ec4e9e58
--- /dev/null
+++ b/arch/powerpc/platforms/ps3/Kconfig
@@ -0,0 +1,54 @@
+menu "PS3 Platform Options"
+        depends on PPC_PS3
+
+config PS3_HTAB_SIZE
+        depends on PPC_PS3
+        int "PS3 Platform pagetable size"
+        range 18 20
+        default 20
+        help
+          This option is only for experts who may have the desire to fine
+          tune the pagetable size on their system.  The value here is
+          expressed as the log2 of the page table size.  Valid values are
+          18, 19, and 20, corresponding to 256KB, 512KB and 1MB respectively.
+
+          If unsure, choose the default (20) with the confidence that your
+          system will have optimal runtime performance.
+
+config PS3_DYNAMIC_DMA
+        depends on PPC_PS3 && EXPERIMENTAL
+        bool "PS3 Platform dynamic DMA page table management"
+        default n
+        help
+          This option will enable kernel support to take advantage of the
+          per device dynamic DMA page table management provided by the Cell
+          processor's IO Controller.  This support incurs some runtime
+          overhead and also slightly increases kernel memory usage.  The
+          current implementation should be considered experimental.
+
+          This support is mainly for Linux kernel development.  If unsure,
+          say N.
+
+config PS3_USE_LPAR_ADDR
+        depends on PPC_PS3 && EXPERIMENTAL
+        bool "PS3 use lpar address space"
+        default y
+        help
+          This option is solely for experimentation by experts.  Disables
+          translation of lpar addresses.  SPE support currently won't work
+          without this set to y.
+
+          If you have any doubt, choose the default y.
+
+config PS3_VUART
+        depends on PPC_PS3
+        bool "PS3 Virtual UART support"
+        default y
+        help
+          Include support for the PS3 Virtual UART.
+
+          This support is required for several system services
+          including the System Manager and AV Settings.  In
+          general, all users will say Y.
+
+endmenu
diff --git a/arch/powerpc/platforms/ps3/Makefile b/arch/powerpc/platforms/ps3/Makefile
new file mode 100644
index 000000000000..3757cfabc8ce
--- /dev/null
+++ b/arch/powerpc/platforms/ps3/Makefile
@@ -0,0 +1,4 @@
+obj-y += setup.o mm.o smp.o time.o hvcall.o htab.o repository.o
+obj-y += interrupt.o exports.o os-area.o
+
+obj-$(CONFIG_SPU_BASE) += spu.o
diff --git a/arch/powerpc/platforms/ps3/exports.c b/arch/powerpc/platforms/ps3/exports.c
new file mode 100644
index 000000000000..a7e8ffd24a65
--- /dev/null
+++ b/arch/powerpc/platforms/ps3/exports.c
@@ -0,0 +1,27 @@
+/*
+ *  PS3 hvcall exports for modules.
+ *
+ *  Copyright (C) 2006 Sony Computer Entertainment Inc.
+ *  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>
+
+#define LV1_CALL(name, in, out, num)                          \
+  extern s64 _lv1_##name(LV1_##in##_IN_##out##_OUT_ARG_DECL); \
+  EXPORT_SYMBOL(_lv1_##name);
+
+#include <asm/lv1call.h>
diff --git a/arch/powerpc/platforms/ps3/htab.c b/arch/powerpc/platforms/ps3/htab.c
new file mode 100644
index 000000000000..8fe1769655a3
--- /dev/null
+++ b/arch/powerpc/platforms/ps3/htab.c
@@ -0,0 +1,277 @@
+/*
+ *  PS3 pagetable management routines.
+ *
+ *  Copyright (C) 2006 Sony Computer Entertainment Inc.
+ *  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/kernel.h>
+
+#include <asm/machdep.h>
+#include <asm/lmb.h>
+#include <asm/udbg.h>
+#include <asm/ps3.h>
+#include <asm/lv1call.h>
+
+#include "platform.h"
+
+#if defined(DEBUG)
+#define DBG(fmt...) udbg_printf(fmt)
+#else
+#define DBG(fmt...) do{if(0)printk(fmt);}while(0)
+#endif
+
+static hpte_t *htab;
+static unsigned long htab_addr;
+static unsigned char *bolttab;
+static unsigned char *inusetab;
+
+static spinlock_t ps3_bolttab_lock = SPIN_LOCK_UNLOCKED;
+
+#define debug_dump_hpte(_a, _b, _c, _d, _e, _f, _g) \
+        _debug_dump_hpte(_a, _b, _c, _d, _e, _f, _g, __func__, __LINE__)
+static void _debug_dump_hpte(unsigned long pa, unsigned long va,
+        unsigned long group, unsigned long bitmap, hpte_t lhpte, int psize,
+        unsigned long slot, const char* func, int line)
+{
+        DBG("%s:%d: pa     = %lxh\n", func, line, pa);
+        DBG("%s:%d: lpar   = %lxh\n", func, line,
+                ps3_mm_phys_to_lpar(pa));
+        DBG("%s:%d: va     = %lxh\n", func, line, va);
+        DBG("%s:%d: group  = %lxh\n", func, line, group);
+        DBG("%s:%d: bitmap = %lxh\n", func, line, bitmap);
+        DBG("%s:%d: hpte.v = %lxh\n", func, line, lhpte.v);
+        DBG("%s:%d: hpte.r = %lxh\n", func, line, lhpte.r);
+        DBG("%s:%d: psize  = %xh\n", func, line, psize);
+        DBG("%s:%d: slot   = %lxh\n", func, line, slot);
+}
+
+static long ps3_hpte_insert(unsigned long hpte_group, unsigned long va,
+        unsigned long pa, unsigned long rflags, unsigned long vflags, int psize)
+{
+        unsigned long slot;
+        hpte_t lhpte;
+        int secondary = 0;
+        unsigned long result;
+        unsigned long bitmap;
+        unsigned long flags;
+        unsigned long p_pteg, s_pteg, b_index, b_mask, cb, ci;
+
+        vflags &= ~HPTE_V_SECONDARY; /* this bit is ignored */
+
+        lhpte.v = hpte_encode_v(va, psize) | vflags | HPTE_V_VALID;
+        lhpte.r = hpte_encode_r(ps3_mm_phys_to_lpar(pa), psize) | rflags;
+
+        p_pteg = hpte_group / HPTES_PER_GROUP;
+        s_pteg = ~p_pteg & htab_hash_mask;
+
+        spin_lock_irqsave(&ps3_bolttab_lock, flags);
+
+        BUG_ON(bolttab[p_pteg] == 0xff && bolttab[s_pteg] == 0xff);
+
+        bitmap = (inusetab[p_pteg] << 8) | inusetab[s_pteg];
+
+        if (bitmap == 0xffff) {
+                /*
+                 * PTEG is full. Search for victim.
+                 */
+                bitmap &= ~((bolttab[p_pteg] << 8) | bolttab[s_pteg]);
+                do {
+                        ci = mftb() & 15;
+                        cb = 0x8000UL >> ci;
+                } while ((cb & bitmap) == 0);
+        } else {
+                /*
+                 * search free slot in hardware order
+                 *      [primary]       0, 2, 4, 6, 1, 3, 5, 7
+                 *      [secondary]     0, 2, 4, 6, 1, 3, 5, 7
+                 */
+                for (ci = 0; ci < HPTES_PER_GROUP; ci += 2) {
+                        cb = 0x8000UL >> ci;
+                        if ((cb & bitmap) == 0)
+                                goto found;
+                }
+                for (ci = 1; ci < HPTES_PER_GROUP; ci += 2) {
+                        cb = 0x8000UL >> ci;
+                        if ((cb & bitmap) == 0)
+                                goto found;
+                }
+                for (ci = HPTES_PER_GROUP; ci < HPTES_PER_GROUP*2; ci += 2) {
+                        cb = 0x8000UL >> ci;
+                        if ((cb & bitmap) == 0)
+                                goto found;
+                }
+                for (ci = HPTES_PER_GROUP+1; ci < HPTES_PER_GROUP*2; ci += 2) {
+                        cb = 0x8000UL >> ci;
+                        if ((cb & bitmap) == 0)
+                                goto found;
+                }
+        }
+
+found:
+        if (ci < HPTES_PER_GROUP) {
+                slot = p_pteg * HPTES_PER_GROUP + ci;
+        } else {
+                slot = s_pteg * HPTES_PER_GROUP + (ci & 7);
+                /* lhpte.dw0.dw0.h = 1; */
+                vflags |= HPTE_V_SECONDARY;
+                lhpte.v |= HPTE_V_SECONDARY;
+        }
+
+        result = lv1_write_htab_entry(0, slot, lhpte.v, lhpte.r);
+
+        if (result) {
+                debug_dump_hpte(pa, va, hpte_group, bitmap, lhpte, psize, slot);
+                BUG();
+        }
+
+        /*
+         * If used slot is not in primary HPTE group,
+         * the slot should be in secondary HPTE group.
+         */
+
+        if ((hpte_group ^ slot) & ~(HPTES_PER_GROUP - 1)) {
+                secondary = 1;
+                b_index = s_pteg;
+        } else {
+                secondary = 0;
+                b_index = p_pteg;
+        }
+
+        b_mask = (lhpte.v & HPTE_V_BOLTED) ? 1 << 7 : 0 << 7;
+        bolttab[b_index] |= b_mask >> (slot & 7);
+        b_mask = 1 << 7;
+        inusetab[b_index] |= b_mask >> (slot & 7);
+        spin_unlock_irqrestore(&ps3_bolttab_lock, flags);
+
+        return (slot & 7) | (secondary << 3);
+}
+
+static long ps3_hpte_remove(unsigned long hpte_group)
+{
+        panic("ps3_hpte_remove() not implemented");
+        return 0;
+}
+
+static long ps3_hpte_updatepp(unsigned long slot, unsigned long newpp,
+        unsigned long va, int psize, int local)
+{
+        unsigned long flags;
+        unsigned long result;
+        unsigned long pteg, bit;
+        unsigned long hpte_v, want_v;
+
+        want_v = hpte_encode_v(va, psize);
+
+        spin_lock_irqsave(&ps3_bolttab_lock, flags);
+
+        hpte_v = htab[slot].v;
+        if (!HPTE_V_COMPARE(hpte_v, want_v) || !(hpte_v & HPTE_V_VALID)) {
+                spin_unlock_irqrestore(&ps3_bolttab_lock, flags);
+
+                /* ps3_hpte_insert() will be used to update PTE */
+                return -1;
+        }
+
+        result = lv1_write_htab_entry(0, slot, 0, 0);
+
+        if (result) {
+                DBG("%s: va=%lx slot=%lx psize=%d result = %ld (0x%lx)\n",
+                       __func__, va, slot, psize, result, result);
+                BUG();
+        }
+
+        pteg = slot / HPTES_PER_GROUP;
+        bit = slot % HPTES_PER_GROUP;
+        inusetab[pteg] &= ~(0x80 >> bit);
+
+        spin_unlock_irqrestore(&ps3_bolttab_lock, flags);
+
+        /* ps3_hpte_insert() will be used to update PTE */
+        return -1;
+}
+
+static void ps3_hpte_updateboltedpp(unsigned long newpp, unsigned long ea,
+        int psize)
+{
+        panic("ps3_hpte_updateboltedpp() not implemented");
+}
+
+static void ps3_hpte_invalidate(unsigned long slot, unsigned long va,
+        int psize, int local)
+{
+        unsigned long flags;
+        unsigned long result;
+        unsigned long pteg, bit;
+
+        spin_lock_irqsave(&ps3_bolttab_lock, flags);
+        result = lv1_write_htab_entry(0, slot, 0, 0);
+
+        if (result) {
+                DBG("%s: va=%lx slot=%lx psize=%d result = %ld (0x%lx)\n",
+                       __func__, va, slot, psize, result, result);
+                BUG();
+        }
+
+        pteg = slot / HPTES_PER_GROUP;
+        bit = slot % HPTES_PER_GROUP;
+        inusetab[pteg] &= ~(0x80 >> bit);
+        spin_unlock_irqrestore(&ps3_bolttab_lock, flags);
+}
+
+static void ps3_hpte_clear(void)
+{
+        lv1_unmap_htab(htab_addr);
+}
+
+void __init ps3_hpte_init(unsigned long htab_size)
+{
+        long bitmap_size;
+
+        DBG(" -> %s:%d\n", __func__, __LINE__);
+
+        ppc_md.hpte_invalidate = ps3_hpte_invalidate;
+        ppc_md.hpte_updatepp = ps3_hpte_updatepp;
+        ppc_md.hpte_updateboltedpp = ps3_hpte_updateboltedpp;
+        ppc_md.hpte_insert = ps3_hpte_insert;
+        ppc_md.hpte_remove = ps3_hpte_remove;
+        ppc_md.hpte_clear_all = ps3_hpte_clear;
+
+        ppc64_pft_size = __ilog2(htab_size);
+
+        bitmap_size = htab_size / sizeof(hpte_t) / 8;
+
+        bolttab = __va(lmb_alloc(bitmap_size, 1));
+        inusetab = __va(lmb_alloc(bitmap_size, 1));
+
+        memset(bolttab, 0, bitmap_size);
+        memset(inusetab, 0, bitmap_size);
+
+        DBG(" <- %s:%d\n", __func__, __LINE__);
+}
+
+void __init ps3_map_htab(void)
+{
+        long result;
+        unsigned long htab_size = (1UL << ppc64_pft_size);
+
+        result = lv1_map_htab(0, &htab_addr);
+
+        htab = (hpte_t *)__ioremap(htab_addr, htab_size, PAGE_READONLY_X);
+
+        DBG("%s:%d: lpar %016lxh, virt %016lxh\n", __func__, __LINE__,
+                htab_addr, (unsigned long)htab);
+}
diff --git a/arch/powerpc/platforms/ps3/hvcall.S b/arch/powerpc/platforms/ps3/hvcall.S
new file mode 100644
index 000000000000..54be6523a0e8
--- /dev/null
+++ b/arch/powerpc/platforms/ps3/hvcall.S
@@ -0,0 +1,804 @@
+/*
+ *  PS3 hvcall interface.
+ *
+ *  Copyright (C) 2006 Sony Computer Entertainment Inc.
+ *  Copyright 2006 Sony Corp.
+ *  Copyright 2003, 2004 (c) MontaVista Software, Inc.
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License 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 <asm/processor.h>
+#include <asm/ppc_asm.h>
+
+#define lv1call .long 0x44000022; extsw r3, r3
+
+#define LV1_N_IN_0_OUT(API_NAME, API_NUMBER)    \
+_GLOBAL(_##API_NAME)                            \
+                                                \
+        mflr    r0;                             \
+        std     r0, 16(r1);                     \
+                                                \
+        li      r11, API_NUMBER;                \
+        lv1call;                                \
+                                                \
+        ld      r0, 16(r1);                     \
+        mtlr    r0;                             \
+        blr
+
+#define LV1_0_IN_0_OUT LV1_N_IN_0_OUT
+#define LV1_1_IN_0_OUT LV1_N_IN_0_OUT
+#define LV1_2_IN_0_OUT LV1_N_IN_0_OUT
+#define LV1_3_IN_0_OUT LV1_N_IN_0_OUT
+#define LV1_4_IN_0_OUT LV1_N_IN_0_OUT
+#define LV1_5_IN_0_OUT LV1_N_IN_0_OUT
+#define LV1_6_IN_0_OUT LV1_N_IN_0_OUT
+#define LV1_7_IN_0_OUT LV1_N_IN_0_OUT
+
+#define LV1_0_IN_1_OUT(API_NAME, API_NUMBER)    \
+_GLOBAL(_##API_NAME)                            \
+                                                \
+        mflr    r0;                             \
+        std     r0, 16(r1);                     \
+                                                \
+        stdu    r3, -8(r1);                     \
+                                                \
+        li      r11, API_NUMBER;                \
+        lv1call;                                \
+                                                \
+        addi    r1, r1, 8;                      \
+        ld      r11, -8(r1);                    \
+        std     r4, 0(r11);                     \
+                                                \
+        ld      r0, 16(r1);                     \
+        mtlr    r0;                             \
+        blr
+
+#define LV1_0_IN_2_OUT(API_NAME, API_NUMBER)    \
+_GLOBAL(_##API_NAME)                            \
+                                                \
+        mflr    r0;                             \
+        std     r0, 16(r1);                     \
+                                                \
+        std     r3, -8(r1);                     \
+        stdu    r4, -16(r1);                    \
+                                                \
+        li      r11, API_NUMBER;                \
+        lv1call;                                \
+                                                \
+        addi    r1, r1, 16;                     \
+        ld      r11, -8(r1);                    \
+        std     r4, 0(r11);                     \
+        ld      r11, -16(r1);                   \
+        std     r5, 0(r11);                     \
+                                                \
+        ld      r0, 16(r1);                     \
+        mtlr    r0;                             \
+        blr
+
+#define LV1_0_IN_3_OUT(API_NAME, API_NUMBER)    \
+_GLOBAL(_##API_NAME)                            \
+                                                \
+        mflr    r0;                             \
+        std     r0, 16(r1);                     \
+                                                \
+        std     r3, -8(r1);                     \
+        std     r4, -16(r1);                    \
+        stdu    r5, -24(r1);                    \
+                                                \
+        li      r11, API_NUMBER;                \
+        lv1call;                                \
+                                                \
+        addi    r1, r1, 24;                     \
+        ld      r11, -8(r1);                    \
+        std     r4, 0(r11);                     \
+        ld      r11, -16(r1);                   \
+        std     r5, 0(r11);                     \
+        ld      r11, -24(r1);                   \
+        std     r6, 0(r11);                     \
+                                                \
+        ld      r0, 16(r1);                     \
+        mtlr    r0;                             \
+        blr
+
+#define LV1_0_IN_7_OUT(API_NAME, API_NUMBER)    \
+_GLOBAL(_##API_NAME)                            \
+                                                \
+        mflr    r0;                             \
+        std     r0, 16(r1);                     \
+                                                \
+        std     r3, -8(r1);                     \
+        std     r4, -16(r1);                    \
+        std     r5, -24(r1);                    \
+        std     r6, -32(r1);                    \
+        std     r7, -40(r1);                    \
+        std     r8, -48(r1);                    \
+        stdu    r9, -56(r1);                    \
+                                                \
+        li      r11, API_NUMBER;                \
+        lv1call;                                \
+                                                \
+        addi    r1, r1, 56;                     \
+        ld      r11, -8(r1);                    \
+        std     r4, 0(r11);                     \
+        ld      r11, -16(r1);                   \
+        std     r5, 0(r11);                     \
+        ld      r11, -24(r1);                   \
+        std     r6, 0(r11);                     \
+        ld      r11, -32(r1);                   \
+        std     r7, 0(r11);                     \
+        ld      r11, -40(r1);                   \
+        std     r8, 0(r11);                     \
+        ld      r11, -48(r1);                   \
+        std     r9, 0(r11);                     \
+        ld      r11, -56(r1);                   \
+        std     r10, 0(r11);                    \
+                                                \
+        ld      r0, 16(r1);                     \
+        mtlr    r0;                             \
+        blr
+
+#define LV1_1_IN_1_OUT(API_NAME, API_NUMBER)    \
+_GLOBAL(_##API_NAME)                            \
+                                                \
+        mflr    r0;                             \
+        std     r0, 16(r1);                     \
+                                                \
+        stdu    r4, -8(r1);                     \
+                                                \
+        li      r11, API_NUMBER;                \
+        lv1call;                                \
+                                                \
+        addi    r1, r1, 8;                      \
+        ld      r11, -8(r1);                    \
+        std     r4, 0(r11);                     \
+                                                \
+        ld      r0, 16(r1);                     \
+        mtlr    r0;                             \
+        blr
+
+#define LV1_1_IN_2_OUT(API_NAME, API_NUMBER)    \
+_GLOBAL(_##API_NAME)                            \
+                                                \
+        mflr    r0;                             \
+        std     r0, 16(r1);                     \
+                                                \
+        std     r4, -8(r1);                     \
+        stdu    r5, -16(r1);                    \
+                                                \
+        li      r11, API_NUMBER;                \
+        lv1call;                                \
+                                                \
+        addi    r1, r1, 16;                     \
+        ld      r11, -8(r1);                    \
+        std     r4, 0(r11);                     \
+        ld      r11, -16(r1);                   \
+        std     r5, 0(r11);                     \
+                                                \
+        ld      r0, 16(r1);                     \
+        mtlr    r0;                             \
+        blr
+
+#define LV1_1_IN_3_OUT(API_NAME, API_NUMBER)    \
+_GLOBAL(_##API_NAME)                            \
+                                                \
+        mflr    r0;                             \
+        std     r0, 16(r1);                     \
+                                                \
+        std     r4, -8(r1);                     \
+        std     r5, -16(r1);                    \
+        stdu    r6, -24(r1);                    \
+                                                \
+        li      r11, API_NUMBER;                \
+        lv1call;                                \
+                                                \
+        addi    r1, r1, 24;                     \
+        ld      r11, -8(r1);                    \
+        std     r4, 0(r11);                     \
+        ld      r11, -16(r1);                   \
+        std     r5, 0(r11);                     \
+        ld      r11, -24(r1);                   \
+        std     r6, 0(r11);                     \
+                                                \
+        ld      r0, 16(r1);                     \
+        mtlr    r0;                             \
+        blr
+
+#define LV1_1_IN_4_OUT(API_NAME, API_NUMBER)    \
+_GLOBAL(_##API_NAME)                            \
+                                                \
+        mflr    r0;                             \
+        std     r0, 16(r1);                     \
+                                                \
+        std     r4, -8(r1);                     \
+        std     r5, -16(r1);                    \
+        std     r6, -24(r1);                    \
+        stdu    r7, -32(r1);                    \
+                                                \
+        li      r11, API_NUMBER;                \
+        lv1call;                                \
+                                                \
+        addi    r1, r1, 32;                     \
+        ld      r11, -8(r1);                    \
+        std     r4, 0(r11);                     \
+        ld      r11, -16(r1);                   \
+        std     r5, 0(r11);                     \
+        ld      r11, -24(r1);                   \
+        std     r6, 0(r11);                     \
+        ld      r11, -32(r1);                   \
+        std     r7, 0(r11);                     \
+                                                \
+        ld      r0, 16(r1);                     \
+        mtlr    r0;                             \
+        blr
+
+#define LV1_1_IN_5_OUT(API_NAME, API_NUMBER)    \
+_GLOBAL(_##API_NAME)                            \
+                                                \
+        mflr    r0;                             \
+        std     r0, 16(r1);                     \
+                                                \
+        std     r4, -8(r1);                     \
+        std     r5, -16(r1);                    \
+        std     r6, -24(r1);                    \
+        std     r7, -32(r1);                    \
+        stdu    r8, -40(r1);                    \
+                                                \
+        li      r11, API_NUMBER;                \
+        lv1call;                                \
+                                                \
+        addi    r1, r1, 40;                     \
+        ld      r11, -8(r1);                    \
+        std     r4, 0(r11);                     \
+        ld      r11, -16(r1);                   \
+        std     r5, 0(r11);                     \
+        ld      r11, -24(r1);                   \
+        std     r6, 0(r11);                     \
+        ld      r11, -32(r1);                   \
+        std     r7, 0(r11);                     \
+        ld      r11, -40(r1);                   \
+        std     r8, 0(r11);                     \
+                                                \
+        ld      r0, 16(r1);                     \
+        mtlr    r0;                             \
+        blr
+
+#define LV1_1_IN_6_OUT(API_NAME, API_NUMBER)    \
+_GLOBAL(_##API_NAME)                            \
+                                                \
+        mflr    r0;                             \
+        std     r0, 16(r1);                     \
+                                                \
+        std     r4, -8(r1);                     \
+        std     r5, -16(r1);                    \
+        std     r6, -24(r1);                    \
+        std     r7, -32(r1);                    \
+        std     r8, -40(r1);                    \
+        stdu    r9, -48(r1);                    \
+                                                \
+        li      r11, API_NUMBER;                \
+        lv1call;                                \
+                                                \
+        addi    r1, r1, 48;                     \
+        ld      r11, -8(r1);                    \
+        std     r4, 0(r11);                     \
+        ld      r11, -16(r1);                   \
+        std     r5, 0(r11);                     \
+        ld      r11, -24(r1);                   \
+        std     r6, 0(r11);                     \
+        ld      r11, -32(r1);                   \
+        std     r7, 0(r11);                     \
+        ld      r11, -40(r1);                   \
+        std     r8, 0(r11);                     \
+        ld      r11, -48(r1);                   \
+        std     r9, 0(r11);                     \
+                                                \
+        ld      r0, 16(r1);                     \
+        mtlr    r0;                             \
+        blr
+
+#define LV1_1_IN_7_OUT(API_NAME, API_NUMBER)    \
+_GLOBAL(_##API_NAME)                            \
+                                                \
+        mflr    r0;                             \
+        std     r0, 16(r1);                     \
+                                                \
+        std     r4, -8(r1);                     \
+        std     r5, -16(r1);                    \
+        std     r6, -24(r1);                    \
+        std     r7, -32(r1);                    \
+        std     r8, -40(r1);                    \
+        std     r9, -48(r1);                    \
+        stdu    r10, -56(r1);                   \
+                                                \
+        li      r11, API_NUMBER;                \
+        lv1call;                                \
+                                                \
+        addi    r1, r1, 56;                     \
+        ld      r11, -8(r1);                    \
+        std     r4, 0(r11);                     \
+        ld      r11, -16(r1);                   \
+        std     r5, 0(r11);                     \
+        ld      r11, -24(r1);                   \
+        std     r6, 0(r11);                     \
+        ld      r11, -32(r1);                   \
+        std     r7, 0(r11);                     \
+        ld      r11, -40(r1);                   \
+        std     r8, 0(r11);                     \
+        ld      r11, -48(r1);                   \
+        std     r9, 0(r11);                     \
+        ld      r11, -56(r1);                   \
+        std     r10, 0(r11);                    \
+                                                \
+        ld      r0, 16(r1);                     \
+        mtlr    r0;                             \
+        blr
+
+#define LV1_2_IN_1_OUT(API_NAME, API_NUMBER)    \
+_GLOBAL(_##API_NAME)                            \
+                                                \
+        mflr    r0;                             \
+        std     r0, 16(r1);                     \
+                                                \
+        stdu    r5, -8(r1);                     \
+                                                \
+        li      r11, API_NUMBER;                \
+        lv1call;                                \
+                                                \
+        addi    r1, r1, 8;                      \
+        ld      r11, -8(r1);                    \
+        std     r4, 0(r11);                     \
+                                                \
+        ld      r0, 16(r1);                     \
+        mtlr    r0;                             \
+        blr
+
+#define LV1_2_IN_2_OUT(API_NAME, API_NUMBER)    \
+_GLOBAL(_##API_NAME)                            \
+                                                \
+        mflr    r0;                             \
+        std     r0, 16(r1);                     \
+                                                \
+        std     r5, -8(r1);                     \
+        stdu    r6, -16(r1);                    \
+                                                \
+        li      r11, API_NUMBER;                \
+        lv1call;                                \
+                                                \
+        addi    r1, r1, 16;                     \
+        ld      r11, -8(r1);                    \
+        std     r4, 0(r11);                     \
+        ld      r11, -16(r1);                   \
+        std     r5, 0(r11);                     \
+                                                \
+        ld      r0, 16(r1);                     \
+        mtlr    r0;                             \
+        blr
+
+#define LV1_2_IN_3_OUT(API_NAME, API_NUMBER)    \
+_GLOBAL(_##API_NAME)                            \
+                                                \
+        mflr    r0;                             \
+        std     r0, 16(r1);                     \
+                                                \
+        std     r5, -8(r1);                     \
+        std     r6, -16(r1);                    \
+        stdu    r7, -24(r1);                    \
+                                                \
+        li      r11, API_NUMBER;                \
+        lv1call;                                \
+                                                \
+        addi    r1, r1, 24;                     \
+        ld      r11, -8(r1);                    \
+        std     r4, 0(r11);                     \
+        ld      r11, -16(r1);                   \
+        std     r5, 0(r11);                     \
+        ld      r11, -24(r1);                   \
+        std     r6, 0(r11);                     \
+                                                \
+        ld      r0, 16(r1);                     \
+        mtlr    r0;                             \
+        blr
+
+#define LV1_2_IN_4_OUT(API_NAME, API_NUMBER)    \
+_GLOBAL(_##API_NAME)                            \
+                                                \
+        mflr    r0;                             \
+        std     r0, 16(r1);                     \
+                                                \
+        std     r5, -8(r1);                     \
+        std     r6, -16(r1);                    \
+        std     r7, -24(r1);                    \
+        stdu    r8, -32(r1);                    \
+                                                \
+        li      r11, API_NUMBER;                \
+        lv1call;                                \
+                                                \
+        addi    r1, r1, 32;                     \
+        ld      r11, -8(r1);                    \
+        std     r4, 0(r11);                     \
+        ld      r11, -16(r1);                   \
+        std     r5, 0(r11);                     \
+        ld      r11, -24(r1);                   \
+        std     r6, 0(r11);                     \
+        ld      r11, -32(r1);                   \
+        std     r7, 0(r11);                     \
+                                                \
+        ld      r0, 16(r1);                     \
+        mtlr    r0;                             \
+        blr
+
+#define LV1_2_IN_5_OUT(API_NAME, API_NUMBER)    \
+_GLOBAL(_##API_NAME)                            \
+                                                \
+        mflr    r0;                             \
+        std     r0, 16(r1);                     \
+                                                \
+        std     r5, -8(r1);                     \
+        std     r6, -16(r1);                    \
+        std     r7, -24(r1);                    \
+        std     r8, -32(r1);                    \
+        stdu    r9, -40(r1);                    \
+                                                \
+        li      r11, API_NUMBER;                \
+        lv1call;                                \
+                                                \
+        addi    r1, r1, 40;                     \
+        ld      r11, -8(r1);                    \
+        std     r4, 0(r11);                     \
+        ld      r11, -16(r1);                   \
+        std     r5, 0(r11);                     \
+        ld      r11, -24(r1);                   \
+        std     r6, 0(r11);                     \
+        ld      r11, -32(r1);                   \
+        std     r7, 0(r11);                     \
+        ld      r11, -40(r1);                   \
+        std     r8, 0(r11);                     \
+                                                \
+        ld      r0, 16(r1);                     \
+        mtlr    r0;                             \
+        blr
+
+#define LV1_3_IN_1_OUT(API_NAME, API_NUMBER)    \
+_GLOBAL(_##API_NAME)                            \
+                                                \
+        mflr    r0;                             \
+        std     r0, 16(r1);                     \
+                                                \
+        stdu    r6, -8(r1);                     \
+                                                \
+        li      r11, API_NUMBER;                \
+        lv1call;                                \
+                                                \
+        addi    r1, r1, 8;                      \
+        ld      r11, -8(r1);                    \
+        std     r4, 0(r11);                     \
+                                                \
+        ld      r0, 16(r1);                     \
+        mtlr    r0;                             \
+        blr
+
+#define LV1_3_IN_2_OUT(API_NAME, API_NUMBER)    \
+_GLOBAL(_##API_NAME)                            \
+                                                \
+        mflr    r0;                             \
+        std     r0, 16(r1);                     \
+                                                \
+        std     r6, -8(r1);                     \
+        stdu    r7, -16(r1);                    \
+                                                \
+        li      r11, API_NUMBER;                \
+        lv1call;                                \
+                                                \
+        addi    r1, r1, 16;                     \
+        ld      r11, -8(r1);                    \
+        std     r4, 0(r11);                     \
+        ld      r11, -16(r1);                   \
+        std     r5, 0(r11);                     \
+                                                \
+        ld      r0, 16(r1);                     \
+        mtlr    r0;                             \
+        blr
+
+#define LV1_3_IN_3_OUT(API_NAME, API_NUMBER)    \
+_GLOBAL(_##API_NAME)                            \
+                                                \
+        mflr    r0;                             \
+        std     r0, 16(r1);                     \
+                                                \
+        std     r6, -8(r1);                     \
+        std     r7, -16(r1);                    \
+        stdu    r8, -24(r1);                    \
+                                                \
+        li      r11, API_NUMBER;                \
+        lv1call;                                \
+                                                \
+        addi    r1, r1, 24;                     \
+        ld      r11, -8(r1);                    \
+        std     r4, 0(r11);                     \
+        ld      r11, -16(r1);                   \
+        std     r5, 0(r11);                     \
+        ld      r11, -24(r1);                   \
+        std     r6, 0(r11);                     \
+                                                \
+        ld      r0, 16(r1);                     \
+        mtlr    r0;                             \
+        blr
+
+#define LV1_4_IN_1_OUT(API_NAME, API_NUMBER)    \
+_GLOBAL(_##API_NAME)                            \
+                                                \
+        mflr    r0;                             \
+        std     r0, 16(r1);                     \
+                                                \
+        stdu    r7, -8(r1);                     \
+                                                \
+        li      r11, API_NUMBER;                \
+        lv1call;                                \
+                                                \
+        addi    r1, r1, 8;                      \
+        ld      r11, -8(r1);                    \
+        std     r4, 0(r11);                     \
+                                                \
+        ld      r0, 16(r1);                     \
+        mtlr    r0;                             \
+        blr
+
+#define LV1_4_IN_2_OUT(API_NAME, API_NUMBER)    \
+_GLOBAL(_##API_NAME)                            \
+                                                \
+        mflr    r0;                             \
+        std     r0, 16(r1);                     \
+                                                \
+        std     r7, -8(r1);                     \
+        stdu    r8, -16(r1);                    \
+                                                \
+        li      r11, API_NUMBER;                \
+        lv1call;                                \
+                                                \
+        addi    r1, r1, 16;                     \
+        ld      r11, -8(r1);                    \
+        std     r4, 0(r11);                     \
+        ld      r11, -16(r1);                   \
+        std     r5, 0(r11);                     \
+                                                \
+        ld      r0, 16(r1);                     \
+        mtlr    r0;                             \
+        blr
+
+#define LV1_4_IN_3_OUT(API_NAME, API_NUMBER)    \
+_GLOBAL(_##API_NAME)                            \
+                                                \
+        mflr    r0;                             \
+        std     r0, 16(r1);                     \
+                                                \
+        std     r7, -8(r1);                     \
+        std     r8, -16(r1);                    \
+        stdu    r9, -24(r1);                    \
+                                                \
+        li      r11, API_NUMBER;                \
+        lv1call;                                \
+                                                \
+        addi    r1, r1, 24;                     \
+        ld      r11, -8(r1);                    \
+        std     r4, 0(r11);                     \
+        ld      r11, -16(r1);                   \
+        std     r5, 0(r11);                     \
+        ld      r11, -24(r1);                   \
+        std     r6, 0(r11);                     \
+                                                \
+        ld      r0, 16(r1);                     \
+        mtlr    r0;                             \
+        blr
+
+#define LV1_5_IN_1_OUT(API_NAME, API_NUMBER)    \
+_GLOBAL(_##API_NAME)                            \
+                                                \
+        mflr    r0;                             \
+        std     r0, 16(r1);                     \
+                                                \
+        stdu    r8, -8(r1);                     \
+                                                \
+        li      r11, API_NUMBER;                \
+        lv1call;                                \
+                                                \
+        addi    r1, r1, 8;                      \
+        ld      r11, -8(r1);                    \
+        std     r4, 0(r11);                     \
+                                                \
+        ld      r0, 16(r1);                     \
+        mtlr    r0;                             \
+        blr
+
+#define LV1_5_IN_2_OUT(API_NAME, API_NUMBER)    \
+_GLOBAL(_##API_NAME)                            \
+                                                \
+        mflr    r0;                             \
+        std     r0, 16(r1);                     \
+                                                \
+        std     r8, -8(r1);                     \
+        stdu    r9, -16(r1);                    \
+                                                \
+        li      r11, API_NUMBER;                \
+        lv1call;                                \
+                                                \
+        addi    r1, r1, 16;                     \
+        ld      r11, -8(r1);                    \
+        std     r4, 0(r11);                     \
+        ld      r11, -16(r1);                   \
+        std     r5, 0(r11);                     \
+                                                \
+        ld      r0, 16(r1);                     \
+        mtlr    r0;                             \
+        blr
+
+#define LV1_5_IN_3_OUT(API_NAME, API_NUMBER)    \
+_GLOBAL(_##API_NAME)                            \
+                                                \
+        mflr    r0;                             \
+        std     r0, 16(r1);                     \
+                                                \
+        std     r8, -8(r1);                     \
+        std     r9, -16(r1);                    \
+        stdu    r10, -24(r1);                   \
+                                                \
+        li      r11, API_NUMBER;                \
+        lv1call;                                \
+                                                \
+        addi    r1, r1, 24;                     \
+        ld      r11, -8(r1);                    \
+        std     r4, 0(r11);                     \
+        ld      r11, -16(r1);                   \
+        std     r5, 0(r11);                     \
+        ld      r11, -24(r1);                   \
+        std     r6, 0(r11);                     \
+                                                \
+        ld      r0, 16(r1);                     \
+        mtlr    r0;                             \
+        blr
+
+#define LV1_6_IN_1_OUT(API_NAME, API_NUMBER)    \
+_GLOBAL(_##API_NAME)                            \
+                                                \
+        mflr    r0;                             \
+        std     r0, 16(r1);                     \
+                                                \
+        stdu    r9, -8(r1);                     \
+                                                \
+        li      r11, API_NUMBER;                \
+        lv1call;                                \
+                                                \
+        addi    r1, r1, 8;                      \
+        ld      r11, -8(r1);                    \
+        std     r4, 0(r11);                     \
+                                                \
+        ld      r0, 16(r1);                     \
+        mtlr    r0;                             \
+        blr
+
+#define LV1_6_IN_2_OUT(API_NAME, API_NUMBER)    \
+_GLOBAL(_##API_NAME)                            \
+                                                \
+        mflr    r0;                             \
+        std     r0, 16(r1);                     \
+                                                \
+        std     r9, -8(r1);                     \
+        stdu    r10, -16(r1);                   \
+                                                \
+        li      r11, API_NUMBER;                \
+        lv1call;                                \
+                                                \
+        addi    r1, r1, 16;                     \
+        ld      r11, -8(r1);                    \
+        std     r4, 0(r11);                     \
+        ld      r11, -16(r1);                   \
+        std     r5, 0(r11);                     \
+                                                \
+        ld      r0, 16(r1);                     \
+        mtlr    r0;                             \
+        blr
+
+#define LV1_6_IN_3_OUT(API_NAME, API_NUMBER)    \
+_GLOBAL(_##API_NAME)                            \
+                                                \
+        mflr    r0;                             \
+        std     r0, 16(r1);                     \
+                                                \
+        std     r9, -8(r1);                     \
+        stdu    r10, -16(r1);                   \
+                                                \
+        li      r11, API_NUMBER;                \
+        lv1call;                                \
+                                                \
+        addi    r1, r1, 16;                     \
+        ld      r11, -8(r1);                    \
+        std     r4, 0(r11);                     \
+        ld      r11, -16(r1);                   \
+        std     r5, 0(r11);                     \
+        ld      r11, 48+8*8(r1);                \
+        std     r6, 0(r11);                     \
+                                                \
+        ld      r0, 16(r1);                     \
+        mtlr    r0;                             \
+        blr
+
+#define LV1_7_IN_1_OUT(API_NAME, API_NUMBER)    \
+_GLOBAL(_##API_NAME)                            \
+                                                \
+        mflr    r0;                             \
+        std     r0, 16(r1);                     \
+                                                \
+        stdu    r10, -8(r1);                    \
+                                                \
+        li      r11, API_NUMBER;                \
+        lv1call;                                \
+                                                \
+        addi    r1, r1, 8;                      \
+        ld      r11, -8(r1);                    \
+        std     r4, 0(r11);                     \
+                                                \
+        ld      r0, 16(r1);                     \
+        mtlr    r0;                             \
+        blr
+
+#define LV1_7_IN_6_OUT(API_NAME, API_NUMBER)    \
+_GLOBAL(_##API_NAME)                            \
+                                                \
+        mflr    r0;                             \
+        std     r0, 16(r1);                     \
+                                                \
+        std     r10, 48+8*7(r1);                \
+                                                \
+        li      r11, API_NUMBER;                \
+        lv1call;                                \
+                                                \
+        ld      r11, 48+8*7(r1);                \
+        std     r4, 0(r11);                     \
+        ld      r11, 48+8*8(r1);                \
+        std     r5, 0(r11);                     \
+        ld      r11, 48+8*9(r1);                \
+        std     r6, 0(r11);                     \
+        ld      r11, 48+8*10(r1);               \
+        std     r7, 0(r11);                     \
+        ld      r11, 48+8*11(r1);               \
+        std     r8, 0(r11);                     \
+        ld      r11, 48+8*12(r1);               \
+        std     r9, 0(r11);                     \
+                                                \
+        ld      r0, 16(r1);                     \
+        mtlr    r0;                             \
+        blr
+
+#define LV1_8_IN_1_OUT(API_NAME, API_NUMBER)    \
+_GLOBAL(_##API_NAME)                            \
+                                                \
+        mflr    r0;                             \
+        std     r0, 16(r1);                     \
+                                                \
+        li      r11, API_NUMBER;                \
+        lv1call;                                \
+                                                \
+        ld      r11, 48+8*8(r1);                \
+        std     r4, 0(r11);                     \
+                                                \
+        ld      r0, 16(r1);                     \
+        mtlr    r0;                             \
+        blr
+
+        .text
+
+/* the lv1 underscored call definitions expand here */
+
+#define LV1_CALL(name, in, out, num) LV1_##in##_IN_##out##_OUT(lv1_##name, num)
+#include <asm/lv1call.h>
diff --git a/arch/powerpc/platforms/ps3/interrupt.c b/arch/powerpc/platforms/ps3/interrupt.c
new file mode 100644
index 000000000000..056c1e4141ba
--- /dev/null
+++ b/arch/powerpc/platforms/ps3/interrupt.c
@@ -0,0 +1,575 @@
+/*
+ *  PS3 interrupt routines.
+ *
+ *  Copyright (C) 2006 Sony Computer Entertainment Inc.
+ *  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/kernel.h>
+#include <linux/module.h>
+#include <linux/irq.h>
+
+#include <asm/machdep.h>
+#include <asm/udbg.h>
+#include <asm/ps3.h>
+#include <asm/lv1call.h>
+
+#include "platform.h"
+
+#if defined(DEBUG)
+#define DBG(fmt...) udbg_printf(fmt)
+#else
+#define DBG(fmt...) do{if(0)printk(fmt);}while(0)
+#endif
+
+/**
+ * ps3_alloc_io_irq - Assign a virq to a system bus device.
+ * interrupt_id: The device interrupt id read from the system repository.
+ * @virq: The assigned Linux virq.
+ *
+ * An io irq represents a non-virtualized device interrupt.  interrupt_id
+ * coresponds to the interrupt number of the interrupt controller.
+ */
+
+int ps3_alloc_io_irq(unsigned int interrupt_id, unsigned int *virq)
+{
+        int result;
+        unsigned long outlet;
+
+        result = lv1_construct_io_irq_outlet(interrupt_id, &outlet);
+
+        if (result) {
+                pr_debug("%s:%d: lv1_construct_io_irq_outlet failed: %s\n",
+                        __func__, __LINE__, ps3_result(result));
+                return result;
+        }
+
+        *virq = irq_create_mapping(NULL, outlet);
+
+        pr_debug("%s:%d: interrupt_id %u => outlet %lu, virq %u\n",
+                __func__, __LINE__, interrupt_id, outlet, *virq);
+
+        return 0;
+}
+
+int ps3_free_io_irq(unsigned int virq)
+{
+        int result;
+
+        result = lv1_destruct_io_irq_outlet(virq_to_hw(virq));
+
+        if (!result)
+                pr_debug("%s:%d: lv1_destruct_io_irq_outlet failed: %s\n",
+                        __func__, __LINE__, ps3_result(result));
+
+        irq_dispose_mapping(virq);
+
+        return result;
+}
+
+/**
+ * ps3_alloc_event_irq - Allocate a virq for use with a system event.
+ * @virq: The assigned Linux virq.
+ *
+ * The virq can be used with lv1_connect_interrupt_event_receive_port() to
+ * arrange to receive events, or with ps3_send_event_locally() to signal
+ * events.
+ */
+
+int ps3_alloc_event_irq(unsigned int *virq)
+{
+        int result;
+        unsigned long outlet;
+
+        result = lv1_construct_event_receive_port(&outlet);
+
+        if (result) {
+                pr_debug("%s:%d: lv1_construct_event_receive_port failed: %s\n",
+                        __func__, __LINE__, ps3_result(result));
+                *virq = NO_IRQ;
+                return result;
+        }
+
+        *virq = irq_create_mapping(NULL, outlet);
+
+        pr_debug("%s:%d: outlet %lu, virq %u\n", __func__, __LINE__, outlet,
+                *virq);
+
+        return 0;
+}
+
+int ps3_free_event_irq(unsigned int virq)
+{
+        int result;
+
+        pr_debug(" -> %s:%d\n", __func__, __LINE__);
+
+        result = lv1_destruct_event_receive_port(virq_to_hw(virq));
+
+        if (result)
+                pr_debug("%s:%d: lv1_destruct_event_receive_port failed: %s\n",
+                        __func__, __LINE__, ps3_result(result));
+
+        irq_dispose_mapping(virq);
+
+        pr_debug(" <- %s:%d\n", __func__, __LINE__);
+        return result;
+}
+
+int ps3_send_event_locally(unsigned int virq)
+{
+        return lv1_send_event_locally(virq_to_hw(virq));
+}
+
+/**
+ * ps3_connect_event_irq - Assign a virq to a system bus device.
+ * @did: The HV device identifier read from the system repository.
+ * @interrupt_id: The device interrupt id read from the system repository.
+ * @virq: The assigned Linux virq.
+ *
+ * An event irq represents a virtual device interrupt.  The interrupt_id
+ * coresponds to the software interrupt number.
+ */
+
+int ps3_connect_event_irq(const struct ps3_device_id *did,
+        unsigned int interrupt_id, unsigned int *virq)
+{
+        int result;
+
+        result = ps3_alloc_event_irq(virq);
+
+        if (result)
+                return result;
+
+        result = lv1_connect_interrupt_event_receive_port(did->bus_id,
+                did->dev_id, virq_to_hw(*virq), interrupt_id);
+
+        if (result) {
+                pr_debug("%s:%d: lv1_connect_interrupt_event_receive_port"
+                        " failed: %s\n", __func__, __LINE__,
+                        ps3_result(result));
+                ps3_free_event_irq(*virq);
+                *virq = NO_IRQ;
+                return result;
+        }
+
+        pr_debug("%s:%d: interrupt_id %u, virq %u\n", __func__, __LINE__,
+                interrupt_id, *virq);
+
+        return 0;
+}
+
+int ps3_disconnect_event_irq(const struct ps3_device_id *did,
+        unsigned int interrupt_id, unsigned int virq)
+{
+        int result;
+
+        pr_debug(" -> %s:%d: interrupt_id %u, virq %u\n", __func__, __LINE__,
+                interrupt_id, virq);
+
+        result = lv1_disconnect_interrupt_event_receive_port(did->bus_id,
+                did->dev_id, virq_to_hw(virq), interrupt_id);
+
+        if (result)
+                pr_debug("%s:%d: lv1_disconnect_interrupt_event_receive_port"
+                        " failed: %s\n", __func__, __LINE__,
+                        ps3_result(result));
+
+        ps3_free_event_irq(virq);
+
+        pr_debug(" <- %s:%d\n", __func__, __LINE__);
+        return result;
+}
+
+/**
+ * ps3_alloc_vuart_irq - Configure the system virtual uart virq.
+ * @virt_addr_bmp: The caller supplied virtual uart interrupt bitmap.
+ * @virq: The assigned Linux virq.
+ *
+ * The system supports only a single virtual uart, so multiple calls without
+ * freeing the interrupt will return a wrong state error.
+ */
+
+int ps3_alloc_vuart_irq(void* virt_addr_bmp, unsigned int *virq)
+{
+        int result;
+        unsigned long outlet;
+        unsigned long lpar_addr;
+
+        BUG_ON(!is_kernel_addr((unsigned long)virt_addr_bmp));
+
+        lpar_addr = ps3_mm_phys_to_lpar(__pa(virt_addr_bmp));
+
+        result = lv1_configure_virtual_uart_irq(lpar_addr, &outlet);
+
+        if (result) {
+                pr_debug("%s:%d: lv1_configure_virtual_uart_irq failed: %s\n",
+                        __func__, __LINE__, ps3_result(result));
+                return result;
+        }
+
+        *virq = irq_create_mapping(NULL, outlet);
+
+        pr_debug("%s:%d: outlet %lu, virq %u\n", __func__, __LINE__,
+                outlet, *virq);
+
+        return 0;
+}
+
+int ps3_free_vuart_irq(unsigned int virq)
+{
+        int result;
+
+        result = lv1_deconfigure_virtual_uart_irq();
+
+        if (result) {
+                pr_debug("%s:%d: lv1_configure_virtual_uart_irq failed: %s\n",
+                        __func__, __LINE__, ps3_result(result));
+                return result;
+        }
+
+        irq_dispose_mapping(virq);
+
+        return result;
+}
+
+/**
+ * ps3_alloc_spe_irq - Configure an spe virq.
+ * @spe_id: The spe_id returned from lv1_construct_logical_spe().
+ * @class: The spe interrupt class {0,1,2}.
+ * @virq: The assigned Linux virq.
+ *
+ */
+
+int ps3_alloc_spe_irq(unsigned long spe_id, unsigned int class,
+        unsigned int *virq)
+{
+        int result;
+        unsigned long outlet;
+
+        BUG_ON(class > 2);
+
+        result = lv1_get_spe_irq_outlet(spe_id, class, &outlet);
+
+        if (result) {
+                pr_debug("%s:%d: lv1_get_spe_irq_outlet failed: %s\n",
+                        __func__, __LINE__, ps3_result(result));
+                return result;
+        }
+
+        *virq = irq_create_mapping(NULL, outlet);
+
+        pr_debug("%s:%d: spe_id %lu, class %u, outlet %lu, virq %u\n",
+                __func__, __LINE__, spe_id, class, outlet, *virq);
+
+        return 0;
+}
+
+int ps3_free_spe_irq(unsigned int virq)
+{
+        irq_dispose_mapping(virq);
+        return 0;
+}
+
+#define PS3_INVALID_OUTLET ((irq_hw_number_t)-1)
+#define PS3_PLUG_MAX 63
+
+/**
+ * struct bmp - a per cpu irq status and mask bitmap structure
+ * @status: 256 bit status bitmap indexed by plug
+ * @unused_1:
+ * @mask: 256 bit mask bitmap indexed by plug
+ * @unused_2:
+ * @lock:
+ * @ipi_debug_brk_mask:
+ *
+ * The HV mantains per SMT thread mappings of HV outlet to HV plug on
+ * behalf of the guest.  These mappings are implemented as 256 bit guest
+ * supplied bitmaps indexed by plug number.  The address of the bitmaps are
+ * registered with the HV through lv1_configure_irq_state_bitmap().
+ *
+ * The HV supports 256 plugs per thread, assigned as {0..255}, for a total
+ * of 512 plugs supported on a processor.  To simplify the logic this
+ * implementation equates HV plug value to linux virq value, constrains each
+ * interrupt to have a system wide unique plug number, and limits the range
+ * of the plug values to map into the first dword of the bitmaps.  This
+ * gives a usable range of plug values of  {NUM_ISA_INTERRUPTS..63}.  Note
+ * that there is no constraint on how many in this set an individual thread
+ * can aquire.
+ */
+
+struct bmp {
+        struct {
+                unsigned long status;
+                unsigned long unused_1[3];
+                unsigned long mask;
+                unsigned long unused_2[3];
+        } __attribute__ ((packed));
+        spinlock_t lock;
+        unsigned long ipi_debug_brk_mask;
+};
+
+/**
+ * struct private - a per cpu data structure
+ * @node: HV node id
+ * @cpu: HV thread id
+ * @bmp: an HV bmp structure
+ */
+
+struct private {
+        unsigned long node;
+        unsigned int cpu;
+        struct bmp bmp;
+};
+
+#if defined(DEBUG)
+static void _dump_64_bmp(const char *header, const unsigned long *p, unsigned cpu,
+        const char* func, int line)
+{
+        pr_debug("%s:%d: %s %u {%04lx_%04lx_%04lx_%04lx}\n",
+                func, line, header, cpu,
+                *p >> 48, (*p >> 32) & 0xffff, (*p >> 16) & 0xffff,
+                *p & 0xffff);
+}
+
+static void __attribute__ ((unused)) _dump_256_bmp(const char *header,
+        const unsigned long *p, unsigned cpu, const char* func, int line)
+{
+        pr_debug("%s:%d: %s %u {%016lx:%016lx:%016lx:%016lx}\n",
+                func, line, header, cpu, p[0], p[1], p[2], p[3]);
+}
+
+#define dump_bmp(_x) _dump_bmp(_x, __func__, __LINE__)
+static void _dump_bmp(struct private* pd, const char* func, int line)
+{
+        unsigned long flags;
+
+        spin_lock_irqsave(&pd->bmp.lock, flags);
+        _dump_64_bmp("stat", &pd->bmp.status, pd->cpu, func, line);
+        _dump_64_bmp("mask", &pd->bmp.mask, pd->cpu, func, line);
+        spin_unlock_irqrestore(&pd->bmp.lock, flags);
+}
+
+#define dump_mask(_x) _dump_mask(_x, __func__, __LINE__)
+static void __attribute__ ((unused)) _dump_mask(struct private* pd,
+        const char* func, int line)
+{
+        unsigned long flags;
+
+        spin_lock_irqsave(&pd->bmp.lock, flags);
+        _dump_64_bmp("mask", &pd->bmp.mask, pd->cpu, func, line);
+        spin_unlock_irqrestore(&pd->bmp.lock, flags);
+}
+#else
+static void dump_bmp(struct private* pd) {};
+#endif /* defined(DEBUG) */
+
+static void chip_mask(unsigned int virq)
+{
+        unsigned long flags;
+        struct private *pd = get_irq_chip_data(virq);
+
+        pr_debug("%s:%d: cpu %u, virq %d\n", __func__, __LINE__, pd->cpu, virq);
+
+        BUG_ON(virq < NUM_ISA_INTERRUPTS);
+        BUG_ON(virq > PS3_PLUG_MAX);
+
+        spin_lock_irqsave(&pd->bmp.lock, flags);
+        pd->bmp.mask &= ~(0x8000000000000000UL >> virq);
+        spin_unlock_irqrestore(&pd->bmp.lock, flags);
+
+        lv1_did_update_interrupt_mask(pd->node, pd->cpu);
+}
+
+static void chip_unmask(unsigned int virq)
+{
+        unsigned long flags;
+        struct private *pd = get_irq_chip_data(virq);
+
+        pr_debug("%s:%d: cpu %u, virq %d\n", __func__, __LINE__, pd->cpu, virq);
+
+        BUG_ON(virq < NUM_ISA_INTERRUPTS);
+        BUG_ON(virq > PS3_PLUG_MAX);
+
+        spin_lock_irqsave(&pd->bmp.lock, flags);
+        pd->bmp.mask |= (0x8000000000000000UL >> virq);
+        spin_unlock_irqrestore(&pd->bmp.lock, flags);
+
+        lv1_did_update_interrupt_mask(pd->node, pd->cpu);
+}
+
+static void chip_eoi(unsigned int virq)
+{
+        lv1_end_of_interrupt(virq);
+}
+
+static struct irq_chip irq_chip = {
+        .typename = "ps3",
+        .mask = chip_mask,
+        .unmask = chip_unmask,
+        .eoi = chip_eoi,
+};
+
+static void host_unmap(struct irq_host *h, unsigned int virq)
+{
+        int result;
+
+        pr_debug("%s:%d: virq %d\n", __func__, __LINE__, virq);
+
+        lv1_disconnect_irq_plug(virq);
+
+        result = set_irq_chip_data(virq, NULL);
+        BUG_ON(result);
+}
+
+static DEFINE_PER_CPU(struct private, private);
+
+static int host_map(struct irq_host *h, unsigned int virq,
+        irq_hw_number_t hwirq)
+{
+        int result;
+        unsigned int cpu;
+
+        pr_debug(" -> %s:%d\n", __func__, __LINE__);
+        pr_debug("%s:%d: hwirq %lu => virq %u\n", __func__, __LINE__, hwirq,
+                virq);
+
+        /* bind this virq to a cpu */
+
+        preempt_disable();
+        cpu = smp_processor_id();
+        result = lv1_connect_irq_plug(virq, hwirq);
+        preempt_enable();
+
+        if (result) {
+                pr_info("%s:%d: lv1_connect_irq_plug failed:"
+                        " %s\n", __func__, __LINE__, ps3_result(result));
+                return -EPERM;
+        }
+
+        result = set_irq_chip_data(virq, &per_cpu(private, cpu));
+        BUG_ON(result);
+
+        set_irq_chip_and_handler(virq, &irq_chip, handle_fasteoi_irq);
+
+        pr_debug(" <- %s:%d\n", __func__, __LINE__);
+        return result;
+}
+
+static struct irq_host_ops host_ops = {
+        .map = host_map,
+        .unmap = host_unmap,
+};
+
+void __init ps3_register_ipi_debug_brk(unsigned int cpu, unsigned int virq)
+{
+        struct private *pd = &per_cpu(private, cpu);
+
+        pd->bmp.ipi_debug_brk_mask = 0x8000000000000000UL >> virq;
+
+        pr_debug("%s:%d: cpu %u, virq %u, mask %lxh\n", __func__, __LINE__,
+                cpu, virq, pd->bmp.ipi_debug_brk_mask);
+}
+
+static int bmp_get_and_clear_status_bit(struct bmp *m)
+{
+        unsigned long flags;
+        unsigned int bit;
+        unsigned long x;
+
+        spin_lock_irqsave(&m->lock, flags);
+
+        /* check for ipi break first to stop this cpu ASAP */
+
+        if (m->status & m->ipi_debug_brk_mask) {
+                m->status &= ~m->ipi_debug_brk_mask;
+                spin_unlock_irqrestore(&m->lock, flags);
+                return __ilog2(m->ipi_debug_brk_mask);
+        }
+
+        x = (m->status & m->mask);
+
+        for (bit = NUM_ISA_INTERRUPTS, x <<= bit; x; bit++, x <<= 1)
+                if (x & 0x8000000000000000UL) {
+                        m->status &= ~(0x8000000000000000UL >> bit);
+                        spin_unlock_irqrestore(&m->lock, flags);
+                        return bit;
+                }
+
+        spin_unlock_irqrestore(&m->lock, flags);
+
+        pr_debug("%s:%d: not found\n", __func__, __LINE__);
+        return -1;
+}
+
+unsigned int ps3_get_irq(void)
+{
+        int plug;
+
+        struct private *pd = &__get_cpu_var(private);
+
+        plug = bmp_get_and_clear_status_bit(&pd->bmp);
+
+        if (plug < 1) {
+                pr_debug("%s:%d: no plug found: cpu %u\n", __func__, __LINE__,
+                        pd->cpu);
+                dump_bmp(&per_cpu(private, 0));
+                dump_bmp(&per_cpu(private, 1));
+                return NO_IRQ;
+        }
+
+#if defined(DEBUG)
+        if (plug < NUM_ISA_INTERRUPTS || plug > PS3_PLUG_MAX) {
+                dump_bmp(&per_cpu(private, 0));
+                dump_bmp(&per_cpu(private, 1));
+                BUG();
+        }
+#endif
+        return plug;
+}
+
+void __init ps3_init_IRQ(void)
+{
+        int result;
+        unsigned long node;
+        unsigned cpu;
+        struct irq_host *host;
+
+        lv1_get_logical_ppe_id(&node);
+
+        host = irq_alloc_host(IRQ_HOST_MAP_NOMAP, 0, &host_ops,
+                PS3_INVALID_OUTLET);
+        irq_set_default_host(host);
+        irq_set_virq_count(PS3_PLUG_MAX + 1);
+
+        for_each_possible_cpu(cpu) {
+                struct private *pd = &per_cpu(private, cpu);
+
+                pd->node = node;
+                pd->cpu = cpu;
+                spin_lock_init(&pd->bmp.lock);
+
+                result = lv1_configure_irq_state_bitmap(node, cpu,
+                        ps3_mm_phys_to_lpar(__pa(&pd->bmp.status)));
+
+                if (result)
+                        pr_debug("%s:%d: lv1_configure_irq_state_bitmap failed:"
+                                " %s\n", __func__, __LINE__,
+                                ps3_result(result));
+        }
+
+        ppc_md.get_irq = ps3_get_irq;
+}
diff --git a/arch/powerpc/platforms/ps3/mm.c b/arch/powerpc/platforms/ps3/mm.c
new file mode 100644
index 000000000000..49c0d010d491
--- /dev/null
+++ b/arch/powerpc/platforms/ps3/mm.c
@@ -0,0 +1,831 @@
+/*
+ *  PS3 address space management.
+ *
+ *  Copyright (C) 2006 Sony Computer Entertainment Inc.
+ *  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/kernel.h>
+#include <linux/module.h>
+#include <linux/memory_hotplug.h>
+
+#include <asm/firmware.h>
+#include <asm/lmb.h>
+#include <asm/udbg.h>
+#include <asm/ps3.h>
+#include <asm/lv1call.h>
+
+#include "platform.h"
+
+#if defined(DEBUG)
+#define DBG(fmt...) udbg_printf(fmt)
+#else
+#define DBG(fmt...) do{if(0)printk(fmt);}while(0)
+#endif
+
+enum {
+#if defined(CONFIG_PS3_USE_LPAR_ADDR)
+        USE_LPAR_ADDR = 1,
+#else
+        USE_LPAR_ADDR = 0,
+#endif
+#if defined(CONFIG_PS3_DYNAMIC_DMA)
+        USE_DYNAMIC_DMA = 1,
+#else
+        USE_DYNAMIC_DMA = 0,
+#endif
+};
+
+enum {
+        PAGE_SHIFT_4K = 12U,
+        PAGE_SHIFT_64K = 16U,
+        PAGE_SHIFT_16M = 24U,
+};
+
+static unsigned long make_page_sizes(unsigned long a, unsigned long b)
+{
+        return (a << 56) | (b << 48);
+}
+
+enum {
+        ALLOCATE_MEMORY_TRY_ALT_UNIT = 0X04,
+        ALLOCATE_MEMORY_ADDR_ZERO = 0X08,
+};
+
+/* valid htab sizes are {18,19,20} = 256K, 512K, 1M */
+
+enum {
+        HTAB_SIZE_MAX = 20U, /* HV limit of 1MB */
+        HTAB_SIZE_MIN = 18U, /* CPU limit of 256KB */
+};
+
+/*============================================================================*/
+/* virtual address space routines                                             */
+/*============================================================================*/
+
+/**
+ * struct mem_region - memory region structure
+ * @base: base address
+ * @size: size in bytes
+ * @offset: difference between base and rm.size
+ */
+
+struct mem_region {
+        unsigned long base;
+        unsigned long size;
+        unsigned long offset;
+};
+
+/**
+ * struct map - address space state variables holder
+ * @total: total memory available as reported by HV
+ * @vas_id - HV virtual address space id
+ * @htab_size: htab size in bytes
+ *
+ * The HV virtual address space (vas) allows for hotplug memory regions.
+ * Memory regions can be created and destroyed in the vas at runtime.
+ * @rm: real mode (bootmem) region
+ * @r1: hotplug memory region(s)
+ *
+ * ps3 addresses
+ * virt_addr: a cpu 'translated' effective address
+ * phys_addr: an address in what Linux thinks is the physical address space
+ * lpar_addr: an address in the HV virtual address space
+ * bus_addr: an io controller 'translated' address on a device bus
+ */
+
+struct map {
+        unsigned long total;
+        unsigned long vas_id;
+        unsigned long htab_size;
+        struct mem_region rm;
+        struct mem_region r1;
+};
+
+#define debug_dump_map(x) _debug_dump_map(x, __func__, __LINE__)
+static void _debug_dump_map(const struct map* m, const char* func, int line)
+{
+        DBG("%s:%d: map.total     = %lxh\n", func, line, m->total);
+        DBG("%s:%d: map.rm.size   = %lxh\n", func, line, m->rm.size);
+        DBG("%s:%d: map.vas_id    = %lu\n", func, line, m->vas_id);
+        DBG("%s:%d: map.htab_size = %lxh\n", func, line, m->htab_size);
+        DBG("%s:%d: map.r1.base   = %lxh\n", func, line, m->r1.base);
+        DBG("%s:%d: map.r1.offset = %lxh\n", func, line, m->r1.offset);
+        DBG("%s:%d: map.r1.size   = %lxh\n", func, line, m->r1.size);
+}
+
+static struct map map;
+
+/**
+ * ps3_mm_phys_to_lpar - translate a linux physical address to lpar address
+ * @phys_addr: linux physical address
+ */
+
+unsigned long ps3_mm_phys_to_lpar(unsigned long phys_addr)
+{
+        BUG_ON(is_kernel_addr(phys_addr));
+        if (USE_LPAR_ADDR)
+                return phys_addr;
+        else
+                return (phys_addr < map.rm.size || phys_addr >= map.total)
+                        ? phys_addr : phys_addr + map.r1.offset;
+}
+
+EXPORT_SYMBOL(ps3_mm_phys_to_lpar);
+
+/**
+ * ps3_mm_vas_create - create the virtual address space
+ */
+
+void __init ps3_mm_vas_create(unsigned long* htab_size)
+{
+        int result;
+        unsigned long start_address;
+        unsigned long size;
+        unsigned long access_right;
+        unsigned long max_page_size;
+        unsigned long flags;
+
+        result = lv1_query_logical_partition_address_region_info(0,
+                &start_address, &size, &access_right, &max_page_size,
+                &flags);
+
+        if (result) {
+                DBG("%s:%d: lv1_query_logical_partition_address_region_info "
+                        "failed: %s\n", __func__, __LINE__,
+                        ps3_result(result));
+                goto fail;
+        }
+
+        if (max_page_size < PAGE_SHIFT_16M) {
+                DBG("%s:%d: bad max_page_size %lxh\n", __func__, __LINE__,
+                        max_page_size);
+                goto fail;
+        }
+
+        BUILD_BUG_ON(CONFIG_PS3_HTAB_SIZE > HTAB_SIZE_MAX);
+        BUILD_BUG_ON(CONFIG_PS3_HTAB_SIZE < HTAB_SIZE_MIN);
+
+        result = lv1_construct_virtual_address_space(CONFIG_PS3_HTAB_SIZE,
+                        2, make_page_sizes(PAGE_SHIFT_16M, PAGE_SHIFT_64K),
+                        &map.vas_id, &map.htab_size);
+
+        if (result) {
+                DBG("%s:%d: lv1_construct_virtual_address_space failed: %s\n",
+                        __func__, __LINE__, ps3_result(result));
+                goto fail;
+        }
+
+        result = lv1_select_virtual_address_space(map.vas_id);
+
+        if (result) {
+                DBG("%s:%d: lv1_select_virtual_address_space failed: %s\n",
+                        __func__, __LINE__, ps3_result(result));
+                goto fail;
+        }
+
+        *htab_size = map.htab_size;
+
+        debug_dump_map(&map);
+
+        return;
+
+fail:
+        panic("ps3_mm_vas_create failed");
+}
+
+/**
+ * ps3_mm_vas_destroy -
+ */
+
+void ps3_mm_vas_destroy(void)
+{
+        if (map.vas_id) {
+                lv1_select_virtual_address_space(0);
+                lv1_destruct_virtual_address_space(map.vas_id);
+                map.vas_id = 0;
+        }
+}
+
+/*============================================================================*/
+/* memory hotplug routines                                                    */
+/*============================================================================*/
+
+/**
+ * ps3_mm_region_create - create a memory region in the vas
+ * @r: pointer to a struct mem_region to accept initialized values
+ * @size: requested region size
+ *
+ * This implementation creates the region with the vas large page size.
+ * @size is rounded down to a multiple of the vas large page size.
+ */
+
+int ps3_mm_region_create(struct mem_region *r, unsigned long size)
+{
+        int result;
+        unsigned long muid;
+
+        r->size = _ALIGN_DOWN(size, 1 << PAGE_SHIFT_16M);
+
+        DBG("%s:%d requested  %lxh\n", __func__, __LINE__, size);
+        DBG("%s:%d actual     %lxh\n", __func__, __LINE__, r->size);
+        DBG("%s:%d difference %lxh (%luMB)\n", __func__, __LINE__,
+                (unsigned long)(size - r->size),
+                (size - r->size) / 1024 / 1024);
+
+        if (r->size == 0) {
+                DBG("%s:%d: size == 0\n", __func__, __LINE__);
+                result = -1;
+                goto zero_region;
+        }
+
+        result = lv1_allocate_memory(r->size, PAGE_SHIFT_16M, 0,
+                ALLOCATE_MEMORY_TRY_ALT_UNIT, &r->base, &muid);
+
+        if (result || r->base < map.rm.size) {
+                DBG("%s:%d: lv1_allocate_memory failed: %s\n",
+                        __func__, __LINE__, ps3_result(result));
+                goto zero_region;
+        }
+
+        r->offset = r->base - map.rm.size;
+        return result;
+
+zero_region:
+        r->size = r->base = r->offset = 0;
+        return result;
+}
+
+/**
+ * ps3_mm_region_destroy - destroy a memory region
+ * @r: pointer to struct mem_region
+ */
+
+void ps3_mm_region_destroy(struct mem_region *r)
+{
+        if (r->base) {
+                lv1_release_memory(r->base);
+                r->size = r->base = r->offset = 0;
+                map.total = map.rm.size;
+        }
+}
+
+/**
+ * ps3_mm_add_memory - hot add memory
+ */
+
+static int __init ps3_mm_add_memory(void)
+{
+        int result;
+        unsigned long start_addr;
+        unsigned long start_pfn;
+        unsigned long nr_pages;
+
+        if (!firmware_has_feature(FW_FEATURE_PS3_LV1))
+                return 0;
+
+        BUG_ON(!mem_init_done);
+
+        start_addr = USE_LPAR_ADDR ? map.r1.base : map.rm.size;
+        start_pfn = start_addr >> PAGE_SHIFT;
+        nr_pages = (map.r1.size + PAGE_SIZE - 1) >> PAGE_SHIFT;
+
+        DBG("%s:%d: start_addr %lxh, start_pfn %lxh, nr_pages %lxh\n",
+                __func__, __LINE__, start_addr, start_pfn, nr_pages);
+
+        result = add_memory(0, start_addr, map.r1.size);
+
+        if (result) {
+                DBG("%s:%d: add_memory failed: (%d)\n",
+                        __func__, __LINE__, result);
+                return result;
+        }
+
+        result = online_pages(start_pfn, nr_pages);
+
+        if (result)
+                DBG("%s:%d: online_pages failed: (%d)\n",
+                        __func__, __LINE__, result);
+
+        return result;
+}
+
+core_initcall(ps3_mm_add_memory);
+
+/*============================================================================*/
+/* dma routines                                                               */
+/*============================================================================*/
+
+/**
+ * dma_lpar_to_bus - Translate an lpar address to ioc mapped bus address.
+ * @r: pointer to dma region structure
+ * @lpar_addr: HV lpar address
+ */
+
+static unsigned long dma_lpar_to_bus(struct ps3_dma_region *r,
+        unsigned long lpar_addr)
+{
+        BUG_ON(lpar_addr >= map.r1.base + map.r1.size);
+        return r->bus_addr + (lpar_addr <= map.rm.size ? lpar_addr
+                : lpar_addr - map.r1.offset);
+}
+
+#define dma_dump_region(_a) _dma_dump_region(_a, __func__, __LINE__)
+static void _dma_dump_region(const struct ps3_dma_region *r, const char* func,
+        int line)
+{
+        DBG("%s:%d: dev        %u:%u\n", func, line, r->did.bus_id,
+                r->did.dev_id);
+        DBG("%s:%d: page_size  %u\n", func, line, r->page_size);
+        DBG("%s:%d: bus_addr   %lxh\n", func, line, r->bus_addr);
+        DBG("%s:%d: len        %lxh\n", func, line, r->len);
+}
+
+/**
+ * dma_chunk - A chunk of dma pages mapped by the io controller.
+ * @region - The dma region that owns this chunk.
+ * @lpar_addr: Starting lpar address of the area to map.
+ * @bus_addr: Starting ioc bus address of the area to map.
+ * @len: Length in bytes of the area to map.
+ * @link: A struct list_head used with struct ps3_dma_region.chunk_list, the
+ * list of all chuncks owned by the region.
+ *
+ * This implementation uses a very simple dma page manager
+ * based on the dma_chunk structure.  This scheme assumes
+ * that all drivers use very well behaved dma ops.
+ */
+
+struct dma_chunk {
+        struct ps3_dma_region *region;
+        unsigned long lpar_addr;
+        unsigned long bus_addr;
+        unsigned long len;
+        struct list_head link;
+        unsigned int usage_count;
+};
+
+#define dma_dump_chunk(_a) _dma_dump_chunk(_a, __func__, __LINE__)
+static void _dma_dump_chunk (const struct dma_chunk* c, const char* func,
+        int line)
+{
+        DBG("%s:%d: r.dev        %u:%u\n", func, line,
+                c->region->did.bus_id, c->region->did.dev_id);
+        DBG("%s:%d: r.bus_addr   %lxh\n", func, line, c->region->bus_addr);
+        DBG("%s:%d: r.page_size  %u\n", func, line, c->region->page_size);
+        DBG("%s:%d: r.len        %lxh\n", func, line, c->region->len);
+        DBG("%s:%d: c.lpar_addr  %lxh\n", func, line, c->lpar_addr);
+        DBG("%s:%d: c.bus_addr   %lxh\n", func, line, c->bus_addr);
+        DBG("%s:%d: c.len        %lxh\n", func, line, c->len);
+}
+
+static struct dma_chunk * dma_find_chunk(struct ps3_dma_region *r,
+        unsigned long bus_addr, unsigned long len)
+{
+        struct dma_chunk *c;
+        unsigned long aligned_bus = _ALIGN_DOWN(bus_addr, 1 << r->page_size);
+        unsigned long aligned_len = _ALIGN_UP(len, 1 << r->page_size);
+
+        list_for_each_entry(c, &r->chunk_list.head, link) {
+                /* intersection */
+                if (aligned_bus >= c->bus_addr
+                        && aligned_bus < c->bus_addr + c->len
+                        && aligned_bus + aligned_len <= c->bus_addr + c->len) {
+                        return c;
+                }
+                /* below */
+                if (aligned_bus + aligned_len <= c->bus_addr) {
+                        continue;
+                }
+                /* above */
+                if (aligned_bus >= c->bus_addr + c->len) {
+                        continue;
+                }
+
+                /* we don't handle the multi-chunk case for now */
+
+                dma_dump_chunk(c);
+                BUG();
+        }
+        return NULL;
+}
+
+static int dma_free_chunk(struct dma_chunk *c)
+{
+        int result = 0;
+
+        if (c->bus_addr) {
+                result = lv1_unmap_device_dma_region(c->region->did.bus_id,
+                        c->region->did.dev_id, c->bus_addr, c->len);
+                BUG_ON(result);
+        }
+
+        kfree(c);
+        return result;
+}
+
+/**
+ * dma_map_pages - Maps dma pages into the io controller bus address space.
+ * @r: Pointer to a struct ps3_dma_region.
+ * @phys_addr: Starting physical address of the area to map.
+ * @len: Length in bytes of the area to map.
+ * c_out: A pointer to receive an allocated struct dma_chunk for this area.
+ *
+ * This is the lowest level dma mapping routine, and is the one that will
+ * make the HV call to add the pages into the io controller address space.
+ */
+
+static int dma_map_pages(struct ps3_dma_region *r, unsigned long phys_addr,
+        unsigned long len, struct dma_chunk **c_out)
+{
+        int result;
+        struct dma_chunk *c;
+
+        c = kzalloc(sizeof(struct dma_chunk), GFP_ATOMIC);
+
+        if (!c) {
+                result = -ENOMEM;
+                goto fail_alloc;
+        }
+
+        c->region = r;
+        c->lpar_addr = ps3_mm_phys_to_lpar(phys_addr);
+        c->bus_addr = dma_lpar_to_bus(r, c->lpar_addr);
+        c->len = len;
+
+        result = lv1_map_device_dma_region(c->region->did.bus_id,
+                c->region->did.dev_id, c->lpar_addr, c->bus_addr, c->len,
+                0xf800000000000000UL);
+
+        if (result) {
+                DBG("%s:%d: lv1_map_device_dma_region failed: %s\n",
+                        __func__, __LINE__, ps3_result(result));
+                goto fail_map;
+        }
+
+        list_add(&c->link, &r->chunk_list.head);
+
+        *c_out = c;
+        return 0;
+
+fail_map:
+        kfree(c);
+fail_alloc:
+        *c_out = NULL;
+        DBG(" <- %s:%d\n", __func__, __LINE__);
+        return result;
+}
+
+/**
+ * dma_region_create - Create a device dma region.
+ * @r: Pointer to a struct ps3_dma_region.
+ *
+ * This is the lowest level dma region create routine, and is the one that
+ * will make the HV call to create the region.
+ */
+
+static int dma_region_create(struct ps3_dma_region* r)
+{
+        int result;
+
+        r->len = _ALIGN_UP(map.total, 1 << r->page_size);
+        INIT_LIST_HEAD(&r->chunk_list.head);
+        spin_lock_init(&r->chunk_list.lock);
+
+        result = lv1_allocate_device_dma_region(r->did.bus_id, r->did.dev_id,
+                r->len, r->page_size, r->region_type, &r->bus_addr);
+
+        dma_dump_region(r);
+
+        if (result) {
+                DBG("%s:%d: lv1_allocate_device_dma_region failed: %s\n",
+                        __func__, __LINE__, ps3_result(result));
+                r->len = r->bus_addr = 0;
+        }
+
+        return result;
+}
+
+/**
+ * dma_region_free - Free a device dma region.
+ * @r: Pointer to a struct ps3_dma_region.
+ *
+ * This is the lowest level dma region free routine, and is the one that
+ * will make the HV call to free the region.
+ */
+
+static int dma_region_free(struct ps3_dma_region* r)
+{
+        int result;
+        struct dma_chunk *c;
+        struct dma_chunk *tmp;
+
+        list_for_each_entry_safe(c, tmp, &r->chunk_list.head, link) {
+                list_del(&c->link);
+                dma_free_chunk(c);
+        }
+
+        result = lv1_free_device_dma_region(r->did.bus_id, r->did.dev_id,
+                r->bus_addr);
+
+        if (result)
+                DBG("%s:%d: lv1_free_device_dma_region failed: %s\n",
+                        __func__, __LINE__, ps3_result(result));
+
+        r->len = r->bus_addr = 0;
+
+        return result;
+}
+
+/**
+ * dma_map_area - Map an area of memory into a device dma region.
+ * @r: Pointer to a struct ps3_dma_region.
+ * @virt_addr: Starting virtual address of the area to map.
+ * @len: Length in bytes of the area to map.
+ * @bus_addr: A pointer to return the starting ioc bus address of the area to
+ * map.
+ *
+ * This is the common dma mapping routine.
+ */
+
+static int dma_map_area(struct ps3_dma_region *r, unsigned long virt_addr,
+        unsigned long len, unsigned long *bus_addr)
+{
+        int result;
+        unsigned long flags;
+        struct dma_chunk *c;
+        unsigned long phys_addr = is_kernel_addr(virt_addr) ? __pa(virt_addr)
+                : virt_addr;
+
+        *bus_addr = dma_lpar_to_bus(r, ps3_mm_phys_to_lpar(phys_addr));
+
+        if (!USE_DYNAMIC_DMA) {
+                unsigned long lpar_addr = ps3_mm_phys_to_lpar(phys_addr);
+                DBG(" -> %s:%d\n", __func__, __LINE__);
+                DBG("%s:%d virt_addr %lxh\n", __func__, __LINE__,
+                        virt_addr);
+                DBG("%s:%d phys_addr %lxh\n", __func__, __LINE__,
+                        phys_addr);
+                DBG("%s:%d lpar_addr %lxh\n", __func__, __LINE__,
+                        lpar_addr);
+                DBG("%s:%d len       %lxh\n", __func__, __LINE__, len);
+                DBG("%s:%d bus_addr  %lxh (%lxh)\n", __func__, __LINE__,
+                *bus_addr, len);
+        }
+
+        spin_lock_irqsave(&r->chunk_list.lock, flags);
+        c = dma_find_chunk(r, *bus_addr, len);
+
+        if (c) {
+                c->usage_count++;
+                spin_unlock_irqrestore(&r->chunk_list.lock, flags);
+                return 0;
+        }
+
+        result = dma_map_pages(r, _ALIGN_DOWN(phys_addr, 1 << r->page_size),
+                _ALIGN_UP(len, 1 << r->page_size), &c);
+
+        if (result) {
+                *bus_addr = 0;
+                DBG("%s:%d: dma_map_pages failed (%d)\n",
+                        __func__, __LINE__, result);
+                spin_unlock_irqrestore(&r->chunk_list.lock, flags);
+                return result;
+        }
+
+        c->usage_count = 1;
+
+        spin_unlock_irqrestore(&r->chunk_list.lock, flags);
+        return result;
+}
+
+/**
+ * dma_unmap_area - Unmap an area of memory from a device dma region.
+ * @r: Pointer to a struct ps3_dma_region.
+ * @bus_addr: The starting ioc bus address of the area to unmap.
+ * @len: Length in bytes of the area to unmap.
+ *
+ * This is the common dma unmap routine.
+ */
+
+int dma_unmap_area(struct ps3_dma_region *r, unsigned long bus_addr,
+        unsigned long len)
+{
+        unsigned long flags;
+        struct dma_chunk *c;
+
+        spin_lock_irqsave(&r->chunk_list.lock, flags);
+        c = dma_find_chunk(r, bus_addr, len);
+
+        if (!c) {
+                unsigned long aligned_bus = _ALIGN_DOWN(bus_addr,
+                        1 << r->page_size);
+                unsigned long aligned_len = _ALIGN_UP(len, 1 << r->page_size);
+                DBG("%s:%d: not found: bus_addr %lxh\n",
+                        __func__, __LINE__, bus_addr);
+                DBG("%s:%d: not found: len %lxh\n",
+                        __func__, __LINE__, len);
+                DBG("%s:%d: not found: aligned_bus %lxh\n",
+                        __func__, __LINE__, aligned_bus);
+                DBG("%s:%d: not found: aligned_len %lxh\n",
+                        __func__, __LINE__, aligned_len);
+                BUG();
+        }
+
+        c->usage_count--;
+
+        if (!c->usage_count) {
+                list_del(&c->link);
+                dma_free_chunk(c);
+        }
+
+        spin_unlock_irqrestore(&r->chunk_list.lock, flags);
+        return 0;
+}
+
+/**
+ * dma_region_create_linear - Setup a linear dma maping for a device.
+ * @r: Pointer to a struct ps3_dma_region.
+ *
+ * This routine creates an HV dma region for the device and maps all available
+ * ram into the io controller bus address space.
+ */
+
+static int dma_region_create_linear(struct ps3_dma_region *r)
+{
+        int result;
+        unsigned long tmp;
+
+        /* force 16M dma pages for linear mapping */
+
+        if (r->page_size != PS3_DMA_16M) {
+                pr_info("%s:%d: forcing 16M pages for linear map\n",
+                        __func__, __LINE__);
+                r->page_size = PS3_DMA_16M;
+        }
+
+        result = dma_region_create(r);
+        BUG_ON(result);
+
+        result = dma_map_area(r, map.rm.base, map.rm.size, &tmp);
+        BUG_ON(result);
+
+        if (USE_LPAR_ADDR)
+                result = dma_map_area(r, map.r1.base, map.r1.size,
+                        &tmp);
+        else
+                result = dma_map_area(r, map.rm.size, map.r1.size,
+                        &tmp);
+
+        BUG_ON(result);
+
+        return result;
+}
+
+/**
+ * dma_region_free_linear - Free a linear dma mapping for a device.
+ * @r: Pointer to a struct ps3_dma_region.
+ *
+ * This routine will unmap all mapped areas and free the HV dma region.
+ */
+
+static int dma_region_free_linear(struct ps3_dma_region *r)
+{
+        int result;
+
+        result = dma_unmap_area(r, dma_lpar_to_bus(r, 0), map.rm.size);
+        BUG_ON(result);
+
+        result = dma_unmap_area(r, dma_lpar_to_bus(r, map.r1.base),
+                map.r1.size);
+        BUG_ON(result);
+
+        result = dma_region_free(r);
+        BUG_ON(result);
+
+        return result;
+}
+
+/**
+ * dma_map_area_linear - Map an area of memory into a device dma region.
+ * @r: Pointer to a struct ps3_dma_region.
+ * @virt_addr: Starting virtual address of the area to map.
+ * @len: Length in bytes of the area to map.
+ * @bus_addr: A pointer to return the starting ioc bus address of the area to
+ * map.
+ *
+ * This routine just returns the coresponding bus address.  Actual mapping
+ * occurs in dma_region_create_linear().
+ */
+
+static int dma_map_area_linear(struct ps3_dma_region *r,
+        unsigned long virt_addr, unsigned long len, unsigned long *bus_addr)
+{
+        unsigned long phys_addr = is_kernel_addr(virt_addr) ? __pa(virt_addr)
+                : virt_addr;
+        *bus_addr = dma_lpar_to_bus(r, ps3_mm_phys_to_lpar(phys_addr));
+        return 0;
+}
+
+/**
+ * dma_unmap_area_linear - Unmap an area of memory from a device dma region.
+ * @r: Pointer to a struct ps3_dma_region.
+ * @bus_addr: The starting ioc bus address of the area to unmap.
+ * @len: Length in bytes of the area to unmap.
+ *
+ * This routine does nothing.  Unmapping occurs in dma_region_free_linear().
+ */
+
+static int dma_unmap_area_linear(struct ps3_dma_region *r,
+        unsigned long bus_addr, unsigned long len)
+{
+        return 0;
+}
+
+int ps3_dma_region_create(struct ps3_dma_region *r)
+{
+        return (USE_DYNAMIC_DMA)
+                ? dma_region_create(r)
+                : dma_region_create_linear(r);
+}
+
+int ps3_dma_region_free(struct ps3_dma_region *r)
+{
+        return (USE_DYNAMIC_DMA)
+                ? dma_region_free(r)
+                : dma_region_free_linear(r);
+}
+
+int ps3_dma_map(struct ps3_dma_region *r, unsigned long virt_addr,
+        unsigned long len, unsigned long *bus_addr)
+{
+        return (USE_DYNAMIC_DMA)
+                ? dma_map_area(r, virt_addr, len, bus_addr)
+                : dma_map_area_linear(r, virt_addr, len, bus_addr);
+}
+
+int ps3_dma_unmap(struct ps3_dma_region *r, unsigned long bus_addr,
+        unsigned long len)
+{
+        return (USE_DYNAMIC_DMA) ? dma_unmap_area(r, bus_addr, len)
+                : dma_unmap_area_linear(r, bus_addr, len);
+}
+
+/*============================================================================*/
+/* system startup routines                                                    */
+/*============================================================================*/
+
+/**
+ * ps3_mm_init - initialize the address space state variables
+ */
+
+void __init ps3_mm_init(void)
+{
+        int result;
+
+        DBG(" -> %s:%d\n", __func__, __LINE__);
+
+        result = ps3_repository_read_mm_info(&map.rm.base, &map.rm.size,
+                &map.total);
+
+        if (result)
+                panic("ps3_repository_read_mm_info() failed");
+
+        map.rm.offset = map.rm.base;
+        map.vas_id = map.htab_size = 0;
+
+        /* this implementation assumes map.rm.base is zero */
+
+        BUG_ON(map.rm.base);
+        BUG_ON(!map.rm.size);
+
+        lmb_add(map.rm.base, map.rm.size);
+        lmb_analyze();
+
+        /* arrange to do this in ps3_mm_add_memory */
+        ps3_mm_region_create(&map.r1, map.total - map.rm.size);
+
+        DBG(" <- %s:%d\n", __func__, __LINE__);
+}
+
+/**
+ * ps3_mm_shutdown - final cleanup of address space
+ */
+
+void ps3_mm_shutdown(void)
+{
+        ps3_mm_region_destroy(&map.r1);
+        map.total = map.rm.size;
+}
diff --git a/arch/powerpc/platforms/ps3/os-area.c b/arch/powerpc/platforms/ps3/os-area.c
new file mode 100644
index 000000000000..58358305dc10
--- /dev/null
+++ b/arch/powerpc/platforms/ps3/os-area.c
@@ -0,0 +1,259 @@
+/*
+ *  PS3 'Other OS' area data.
+ *
+ *  Copyright (C) 2006 Sony Computer Entertainment Inc.
+ *  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/kernel.h>
+#include <linux/io.h>
+
+#include <asm/lmb.h>
+#include <asm/ps3.h>
+
+#include "platform.h"
+
+enum {
+        OS_AREA_SEGMENT_SIZE = 0X200,
+};
+
+enum {
+        HEADER_LDR_FORMAT_RAW = 0,
+        HEADER_LDR_FORMAT_GZIP = 1,
+};
+
+/**
+ * struct os_area_header - os area header segment.
+ * @magic_num: Always 'cell_ext_os_area'.
+ * @hdr_version: Header format version number.
+ * @os_area_offset: Starting segment number of os image area.
+ * @ldr_area_offset: Starting segment number of bootloader image area.
+ * @ldr_format: HEADER_LDR_FORMAT flag.
+ * @ldr_size: Size of bootloader image in bytes.
+ *
+ * Note that the docs refer to area offsets.  These are offsets in units of
+ * segments from the start of the os area (top of the header).  These are
+ * better thought of as segment numbers.  The os area of the os area is
+ * reserved for the os image.
+ */
+
+struct os_area_header {
+        s8 magic_num[16];
+        u32 hdr_version;
+        u32 os_area_offset;
+        u32 ldr_area_offset;
+        u32 _reserved_1;
+        u32 ldr_format;
+        u32 ldr_size;
+        u32 _reserved_2[6];
+} __attribute__ ((packed));
+
+enum {
+        PARAM_BOOT_FLAG_GAME_OS = 0,
+        PARAM_BOOT_FLAG_OTHER_OS = 1,
+};
+
+enum {
+        PARAM_AV_MULTI_OUT_NTSC = 0,
+        PARAM_AV_MULTI_OUT_PAL_RGB = 1,
+        PARAM_AV_MULTI_OUT_PAL_YCBCR = 2,
+        PARAM_AV_MULTI_OUT_SECAM = 3,
+};
+
+enum {
+        PARAM_CTRL_BUTTON_O_IS_YES = 0,
+        PARAM_CTRL_BUTTON_X_IS_YES = 1,
+};
+
+/**
+ * struct os_area_params - os area params segment.
+ * @boot_flag: User preference of operating system, PARAM_BOOT_FLAG flag.
+ * @num_params: Number of params in this (params) segment.
+ * @rtc_diff: Difference in seconds between 1970 and the ps3 rtc value.
+ * @av_multi_out: User preference of AV output, PARAM_AV_MULTI_OUT flag.
+ * @ctrl_button: User preference of controller button config, PARAM_CTRL_BUTTON
+ *      flag.
+ * @static_ip_addr: User preference of static IP address.
+ * @network_mask: User preference of static network mask.
+ * @default_gateway: User preference of static default gateway.
+ * @dns_primary: User preference of static primary dns server.
+ * @dns_secondary: User preference of static secondary dns server.
+ *
+ * User preference of zero for static_ip_addr means use dhcp.
+ */
+
+struct os_area_params {
+        u32 boot_flag;
+        u32 _reserved_1[3];
+        u32 num_params;
+        u32 _reserved_2[3];
+        /* param 0 */
+        s64 rtc_diff;
+        u8 av_multi_out;
+        u8 ctrl_button;
+        u8 _reserved_3[6];
+        /* param 1 */
+        u8 static_ip_addr[4];
+        u8 network_mask[4];
+        u8 default_gateway[4];
+        u8 _reserved_4[4];
+        /* param 2 */
+        u8 dns_primary[4];
+        u8 dns_secondary[4];
+        u8 _reserved_5[8];
+} __attribute__ ((packed));
+
+/**
+ * struct saved_params - Static working copies of data from the 'Other OS' area.
+ *
+ * For the convinience of the guest, the HV makes a copy of the 'Other OS' area
+ * in flash to a high address in the boot memory region and then puts that RAM
+ * address and the byte count into the repository for retreval by the guest.
+ * We copy the data we want into a static variable and allow the memory setup
+ * by the HV to be claimed by the lmb manager.
+ */
+
+struct saved_params {
+        /* param 0 */
+        s64 rtc_diff;
+        unsigned int av_multi_out;
+        unsigned int ctrl_button;
+        /* param 1 */
+        u8 static_ip_addr[4];
+        u8 network_mask[4];
+        u8 default_gateway[4];
+        /* param 2 */
+        u8 dns_primary[4];
+        u8 dns_secondary[4];
+} static saved_params;
+
+#define dump_header(_a) _dump_header(_a, __func__, __LINE__)
+static void _dump_header(const struct os_area_header __iomem *h, const char* func,
+        int line)
+{
+        pr_debug("%s:%d: h.magic_num:         '%s'\n", func, line,
+                h->magic_num);
+        pr_debug("%s:%d: h.hdr_version:       %u\n", func, line,
+                h->hdr_version);
+        pr_debug("%s:%d: h.os_area_offset:   %u\n", func, line,
+                h->os_area_offset);
+        pr_debug("%s:%d: h.ldr_area_offset: %u\n", func, line,
+                h->ldr_area_offset);
+        pr_debug("%s:%d: h.ldr_format:        %u\n", func, line,
+                h->ldr_format);
+        pr_debug("%s:%d: h.ldr_size:          %xh\n", func, line,
+                h->ldr_size);
+}
+
+#define dump_params(_a) _dump_params(_a, __func__, __LINE__)
+static void _dump_params(const struct os_area_params __iomem *p, const char* func,
+        int line)
+{
+        pr_debug("%s:%d: p.boot_flag:       %u\n", func, line, p->boot_flag);
+        pr_debug("%s:%d: p.num_params:      %u\n", func, line, p->num_params);
+        pr_debug("%s:%d: p.rtc_diff         %ld\n", func, line, p->rtc_diff);
+        pr_debug("%s:%d: p.av_multi_out     %u\n", func, line, p->av_multi_out);
+        pr_debug("%s:%d: p.ctrl_button:     %u\n", func, line, p->ctrl_button);
+        pr_debug("%s:%d: p.static_ip_addr:  %u.%u.%u.%u\n", func, line,
+                p->static_ip_addr[0], p->static_ip_addr[1],
+                p->static_ip_addr[2], p->static_ip_addr[3]);
+        pr_debug("%s:%d: p.network_mask:    %u.%u.%u.%u\n", func, line,
+                p->network_mask[0], p->network_mask[1],
+                p->network_mask[2], p->network_mask[3]);
+        pr_debug("%s:%d: p.default_gateway: %u.%u.%u.%u\n", func, line,
+                p->default_gateway[0], p->default_gateway[1],
+                p->default_gateway[2], p->default_gateway[3]);
+        pr_debug("%s:%d: p.dns_primary:     %u.%u.%u.%u\n", func, line,
+                p->dns_primary[0], p->dns_primary[1],
+                p->dns_primary[2], p->dns_primary[3]);
+        pr_debug("%s:%d: p.dns_secondary:   %u.%u.%u.%u\n", func, line,
+                p->dns_secondary[0], p->dns_secondary[1],
+                p->dns_secondary[2], p->dns_secondary[3]);
+}
+
+static int __init verify_header(const struct os_area_header *header)
+{
+        if (memcmp(header->magic_num, "cell_ext_os_area", 16)) {
+                pr_debug("%s:%d magic_num failed\n", __func__, __LINE__);
+                return -1;
+        }
+
+        if (header->hdr_version < 1) {
+                pr_debug("%s:%d hdr_version failed\n", __func__, __LINE__);
+                return -1;
+        }
+
+        if (header->os_area_offset > header->ldr_area_offset) {
+                pr_debug("%s:%d offsets failed\n", __func__, __LINE__);
+                return -1;
+        }
+
+        return 0;
+}
+
+int __init ps3_os_area_init(void)
+{
+        int result;
+        u64 lpar_addr;
+        unsigned int size;
+        struct os_area_header *header;
+        struct os_area_params *params;
+
+        result = ps3_repository_read_boot_dat_info(&lpar_addr, &size);
+
+        if (result) {
+                pr_debug("%s:%d ps3_repository_read_boot_dat_info failed\n",
+                        __func__, __LINE__);
+                return result;
+        }
+
+        header = (struct os_area_header *)__va(lpar_addr);
+        params = (struct os_area_params *)__va(lpar_addr + OS_AREA_SEGMENT_SIZE);
+
+        result = verify_header(header);
+
+        if (result) {
+                pr_debug("%s:%d verify_header failed\n", __func__, __LINE__);
+                dump_header(header);
+                return -EIO;
+        }
+
+        dump_header(header);
+        dump_params(params);
+
+        saved_params.rtc_diff = params->rtc_diff;
+        saved_params.av_multi_out = params->av_multi_out;
+        saved_params.ctrl_button = params->ctrl_button;
+        memcpy(saved_params.static_ip_addr, params->static_ip_addr, 4);
+        memcpy(saved_params.network_mask, params->network_mask, 4);
+        memcpy(saved_params.default_gateway, params->default_gateway, 4);
+        memcpy(saved_params.dns_secondary, params->dns_secondary, 4);
+
+        return result;
+}
+
+/**
+ * ps3_os_area_rtc_diff - Returns the ps3 rtc diff value.
+ *
+ * The ps3 rtc maintains a value that approximates seconds since
+ * 2000-01-01 00:00:00 UTC.  Returns the exact number of seconds from 1970 to
+ * 2000 when saved_params.rtc_diff has not been properly set up.
+ */
+
+u64 ps3_os_area_rtc_diff(void)
+{
+        return saved_params.rtc_diff ? saved_params.rtc_diff : 946684800UL;
+}
diff --git a/arch/powerpc/platforms/ps3/platform.h b/arch/powerpc/platforms/ps3/platform.h
new file mode 100644
index 000000000000..23b111bea9d0
--- /dev/null
+++ b/arch/powerpc/platforms/ps3/platform.h
@@ -0,0 +1,68 @@
+/*
+ *  PS3 platform declarations.
+ *
+ *  Copyright (C) 2006 Sony Computer Entertainment Inc.
+ *  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
+ */
+
+#if !defined(_PS3_PLATFORM_H)
+#define _PS3_PLATFORM_H
+
+#include <linux/rtc.h>
+
+/* htab */
+
+void __init ps3_hpte_init(unsigned long htab_size);
+void __init ps3_map_htab(void);
+
+/* mm */
+
+void __init ps3_mm_init(void);
+void __init ps3_mm_vas_create(unsigned long* htab_size);
+void ps3_mm_vas_destroy(void);
+void ps3_mm_shutdown(void);
+
+/* irq */
+
+void ps3_init_IRQ(void);
+void __init ps3_register_ipi_debug_brk(unsigned int cpu, unsigned int virq);
+
+/* smp */
+
+void smp_init_ps3(void);
+void ps3_smp_cleanup_cpu(int cpu);
+
+/* time */
+
+void __init ps3_calibrate_decr(void);
+unsigned long __init ps3_get_boot_time(void);
+void ps3_get_rtc_time(struct rtc_time *time);
+int ps3_set_rtc_time(struct rtc_time *time);
+
+/* os area */
+
+int __init ps3_os_area_init(void);
+u64 ps3_os_area_rtc_diff(void);
+
+/* spu */
+
+#if defined(CONFIG_SPU_BASE)
+void ps3_spu_set_platform (void);
+#else
+static inline void ps3_spu_set_platform (void) {}
+#endif
+
+#endif
diff --git a/arch/powerpc/platforms/ps3/repository.c b/arch/powerpc/platforms/ps3/repository.c
new file mode 100644
index 000000000000..273a0d621bdd
--- /dev/null
+++ b/arch/powerpc/platforms/ps3/repository.c
@@ -0,0 +1,840 @@
+/*
+ *  PS3 repository routines.
+ *
+ *  Copyright (C) 2006 Sony Computer Entertainment Inc.
+ *  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 <asm/ps3.h>
+#include <asm/lv1call.h>
+
+enum ps3_vendor_id {
+        PS3_VENDOR_ID_NONE = 0,
+        PS3_VENDOR_ID_SONY = 0x8000000000000000UL,
+};
+
+enum ps3_lpar_id {
+        PS3_LPAR_ID_CURRENT = 0,
+        PS3_LPAR_ID_PME = 1,
+};
+
+#define dump_field(_a, _b) _dump_field(_a, _b, __func__, __LINE__)
+static void _dump_field(const char *hdr, u64 n, const char* func, int line)
+{
+#if defined(DEBUG)
+        char s[16];
+        const char *const in = (const char *)&n;
+        unsigned int i;
+
+        for (i = 0; i < 8; i++)
+                s[i] = (in[i] <= 126 && in[i] >= 32) ? in[i] : '.';
+        s[i] = 0;
+
+        pr_debug("%s:%d: %s%016lx : %s\n", func, line, hdr, n, s);
+#endif
+}
+
+#define dump_node_name(_a, _b, _c, _d, _e) \
+        _dump_node_name(_a, _b, _c, _d, _e, __func__, __LINE__)
+static void _dump_node_name (unsigned int lpar_id, u64 n1, u64 n2, u64 n3,
+        u64 n4, const char* func, int line)
+{
+        pr_debug("%s:%d: lpar: %u\n", func, line, lpar_id);
+        _dump_field("n1: ", n1, func, line);
+        _dump_field("n2: ", n2, func, line);
+        _dump_field("n3: ", n3, func, line);
+        _dump_field("n4: ", n4, func, line);
+}
+
+#define dump_node(_a, _b, _c, _d, _e, _f, _g) \
+        _dump_node(_a, _b, _c, _d, _e, _f, _g, __func__, __LINE__)
+static void _dump_node(unsigned int lpar_id, u64 n1, u64 n2, u64 n3, u64 n4,
+        u64 v1, u64 v2, const char* func, int line)
+{
+        pr_debug("%s:%d: lpar: %u\n", func, line, lpar_id);
+        _dump_field("n1: ", n1, func, line);
+        _dump_field("n2: ", n2, func, line);
+        _dump_field("n3: ", n3, func, line);
+        _dump_field("n4: ", n4, func, line);
+        pr_debug("%s:%d: v1: %016lx\n", func, line, v1);
+        pr_debug("%s:%d: v2: %016lx\n", func, line, v2);
+}
+
+/**
+ * make_first_field - Make the first field of a repository node name.
+ * @text: Text portion of the field.
+ * @index: Numeric index portion of the field.  Use zero for 'don't care'.
+ *
+ * This routine sets the vendor id to zero (non-vendor specific).
+ * Returns field value.
+ */
+
+static u64 make_first_field(const char *text, u64 index)
+{
+        u64 n;
+
+        strncpy((char *)&n, text, 8);
+        return PS3_VENDOR_ID_NONE + (n >> 32) + index;
+}
+
+/**
+ * make_field - Make subsequent fields of a repository node name.
+ * @text: Text portion of the field.  Use "" for 'don't care'.
+ * @index: Numeric index portion of the field.  Use zero for 'don't care'.
+ *
+ * Returns field value.
+ */
+
+static u64 make_field(const char *text, u64 index)
+{
+        u64 n;
+
+        strncpy((char *)&n, text, 8);
+        return n + index;
+}
+
+/**
+ * read_node - Read a repository node from raw fields.
+ * @n1: First field of node name.
+ * @n2: Second field of node name.  Use zero for 'don't care'.
+ * @n3: Third field of node name.  Use zero for 'don't care'.
+ * @n4: Fourth field of node name.  Use zero for 'don't care'.
+ * @v1: First repository value (high word).
+ * @v2: Second repository value (low word).  Optional parameter, use zero
+ *      for 'don't care'.
+ */
+
+static int read_node(unsigned int lpar_id, u64 n1, u64 n2, u64 n3, u64 n4,
+        u64 *_v1, u64 *_v2)
+{
+        int result;
+        u64 v1;
+        u64 v2;
+
+        if (lpar_id == PS3_LPAR_ID_CURRENT) {
+                u64 id;
+                lv1_get_logical_partition_id(&id);
+                lpar_id = id;
+        }
+
+        result = lv1_get_repository_node_value(lpar_id, n1, n2, n3, n4, &v1,
+                &v2);
+
+        if (result) {
+                pr_debug("%s:%d: lv1_get_repository_node_value failed: %s\n",
+                        __func__, __LINE__, ps3_result(result));
+                dump_node_name(lpar_id, n1, n2, n3, n4);
+                return result;
+        }
+
+        dump_node(lpar_id, n1, n2, n3, n4, v1, v2);
+
+        if (_v1)
+                *_v1 = v1;
+        if (_v2)
+                *_v2 = v2;
+
+        if (v1 && !_v1)
+                pr_debug("%s:%d: warning: discarding non-zero v1: %016lx\n",
+                        __func__, __LINE__, v1);
+        if (v2 && !_v2)
+                pr_debug("%s:%d: warning: discarding non-zero v2: %016lx\n",
+                        __func__, __LINE__, v2);
+
+        return result;
+}
+
+int ps3_repository_read_bus_str(unsigned int bus_index, const char *bus_str,
+        u64 *value)
+{
+        return read_node(PS3_LPAR_ID_PME,
+                make_first_field("bus", bus_index),
+                make_field(bus_str, 0),
+                0, 0,
+                value, 0);
+}
+
+int ps3_repository_read_bus_id(unsigned int bus_index, unsigned int *bus_id)
+{
+        int result;
+        u64 v1;
+        u64 v2; /* unused */
+
+        result = read_node(PS3_LPAR_ID_PME,
+                make_first_field("bus", bus_index),
+                make_field("id", 0),
+                0, 0,
+                &v1, &v2);
+        *bus_id = v1;
+        return result;
+}
+
+int ps3_repository_read_bus_type(unsigned int bus_index,
+        enum ps3_bus_type *bus_type)
+{
+        int result;
+        u64 v1;
+
+        result = read_node(PS3_LPAR_ID_PME,
+                make_first_field("bus", bus_index),
+                make_field("type", 0),
+                0, 0,
+                &v1, 0);
+        *bus_type = v1;
+        return result;
+}
+
+int ps3_repository_read_bus_num_dev(unsigned int bus_index,
+        unsigned int *num_dev)
+{
+        int result;
+        u64 v1;
+
+        result = read_node(PS3_LPAR_ID_PME,
+                make_first_field("bus", bus_index),
+                make_field("num_dev", 0),
+                0, 0,
+                &v1, 0);
+        *num_dev = v1;
+        return result;
+}
+
+int ps3_repository_read_dev_str(unsigned int bus_index,
+        unsigned int dev_index, const char *dev_str, u64 *value)
+{
+        return read_node(PS3_LPAR_ID_PME,
+                make_first_field("bus", bus_index),
+                make_field("dev", dev_index),
+                make_field(dev_str, 0),
+                0,
+                value, 0);
+}
+
+int ps3_repository_read_dev_id(unsigned int bus_index, unsigned int dev_index,
+        unsigned int *dev_id)
+{
+        int result;
+        u64 v1;
+
+        result = read_node(PS3_LPAR_ID_PME,
+                make_first_field("bus", bus_index),
+                make_field("dev", dev_index),
+                make_field("id", 0),
+                0,
+                &v1, 0);
+        *dev_id = v1;
+        return result;
+}
+
+int ps3_repository_read_dev_type(unsigned int bus_index,
+        unsigned int dev_index, enum ps3_dev_type *dev_type)
+{
+        int result;
+        u64 v1;
+
+        result = read_node(PS3_LPAR_ID_PME,
+                make_first_field("bus", bus_index),
+                make_field("dev", dev_index),
+                make_field("type", 0),
+                0,
+                &v1, 0);
+        *dev_type = v1;
+        return result;
+}
+
+int ps3_repository_read_dev_intr(unsigned int bus_index,
+        unsigned int dev_index, unsigned int intr_index,
+        unsigned int *intr_type, unsigned int* interrupt_id)
+{
+        int result;
+        u64 v1;
+        u64 v2;
+
+        result = read_node(PS3_LPAR_ID_PME,
+                make_first_field("bus", bus_index),
+                make_field("dev", dev_index),
+                make_field("intr", intr_index),
+                0,
+                &v1, &v2);
+        *intr_type = v1;
+        *interrupt_id = v2;
+        return result;
+}
+
+int ps3_repository_read_dev_reg_type(unsigned int bus_index,
+        unsigned int dev_index, unsigned int reg_index, unsigned int *reg_type)
+{
+        int result;
+        u64 v1;
+
+        result = read_node(PS3_LPAR_ID_PME,
+                make_first_field("bus", bus_index),
+                make_field("dev", dev_index),
+                make_field("reg", reg_index),
+                make_field("type", 0),
+                &v1, 0);
+        *reg_type = v1;
+        return result;
+}
+
+int ps3_repository_read_dev_reg_addr(unsigned int bus_index,
+        unsigned int dev_index, unsigned int reg_index, u64 *bus_addr, u64 *len)
+{
+        return read_node(PS3_LPAR_ID_PME,
+                make_first_field("bus", bus_index),
+                make_field("dev", dev_index),
+                make_field("reg", reg_index),
+                make_field("data", 0),
+                bus_addr, len);
+}
+
+int ps3_repository_read_dev_reg(unsigned int bus_index,
+        unsigned int dev_index, unsigned int reg_index, unsigned int *reg_type,
+        u64 *bus_addr, u64 *len)
+{
+        int result = ps3_repository_read_dev_reg_type(bus_index, dev_index,
+                reg_index, reg_type);
+        return result ? result
+                : ps3_repository_read_dev_reg_addr(bus_index, dev_index,
+                reg_index, bus_addr, len);
+}
+
+#if defined(DEBUG)
+int ps3_repository_dump_resource_info(unsigned int bus_index,
+        unsigned int dev_index)
+{
+        int result = 0;
+        unsigned int res_index;
+
+        pr_debug(" -> %s:%d: (%u:%u)\n", __func__, __LINE__,
+                bus_index, dev_index);
+
+        for (res_index = 0; res_index < 10; res_index++) {
+                enum ps3_interrupt_type intr_type;
+                unsigned int interrupt_id;
+
+                result = ps3_repository_read_dev_intr(bus_index, dev_index,
+                        res_index, &intr_type, &interrupt_id);
+
+                if (result) {
+                        if (result !=  LV1_NO_ENTRY)
+                                pr_debug("%s:%d ps3_repository_read_dev_intr"
+                                        " (%u:%u) failed\n", __func__, __LINE__,
+                                        bus_index, dev_index);
+                        break;
+                }
+
+                pr_debug("%s:%d (%u:%u) intr_type %u, interrupt_id %u\n",
+                        __func__, __LINE__, bus_index, dev_index, intr_type,
+                        interrupt_id);
+        }
+
+        for (res_index = 0; res_index < 10; res_index++) {
+                enum ps3_region_type reg_type;
+                u64 bus_addr;
+                u64 len;
+
+                result = ps3_repository_read_dev_reg(bus_index, dev_index,
+                        res_index, &reg_type, &bus_addr, &len);
+
+                if (result) {
+                        if (result !=  LV1_NO_ENTRY)
+                                pr_debug("%s:%d ps3_repository_read_dev_reg"
+                                        " (%u:%u) failed\n", __func__, __LINE__,
+                                        bus_index, dev_index);
+                        break;
+                }
+
+                pr_debug("%s:%d (%u:%u) reg_type %u, bus_addr %lxh, len %lxh\n",
+                        __func__, __LINE__, bus_index, dev_index, reg_type,
+                        bus_addr, len);
+        }
+
+        pr_debug(" <- %s:%d\n", __func__, __LINE__);
+        return result;
+}
+
+static int dump_device_info(unsigned int bus_index, unsigned int num_dev)
+{
+        int result = 0;
+        unsigned int dev_index;
+
+        pr_debug(" -> %s:%d: bus_%u\n", __func__, __LINE__, bus_index);
+
+        for (dev_index = 0; dev_index < num_dev; dev_index++) {
+                enum ps3_dev_type dev_type;
+                unsigned int dev_id;
+
+                result = ps3_repository_read_dev_type(bus_index, dev_index,
+                        &dev_type);
+
+                if (result) {
+                        pr_debug("%s:%d ps3_repository_read_dev_type"
+                                " (%u:%u) failed\n", __func__, __LINE__,
+                                bus_index, dev_index);
+                        break;
+                }
+
+                result = ps3_repository_read_dev_id(bus_index, dev_index,
+                        &dev_id);
+
+                if (result) {
+                        pr_debug("%s:%d ps3_repository_read_dev_id"
+                                " (%u:%u) failed\n", __func__, __LINE__,
+                                bus_index, dev_index);
+                        continue;
+                }
+
+                pr_debug("%s:%d  (%u:%u): dev_type %u, dev_id %u\n", __func__,
+                        __LINE__, bus_index, dev_index, dev_type, dev_id);
+
+                ps3_repository_dump_resource_info(bus_index, dev_index);
+        }
+
+        pr_debug(" <- %s:%d\n", __func__, __LINE__);
+        return result;
+}
+
+int ps3_repository_dump_bus_info(void)
+{
+        int result = 0;
+        unsigned int bus_index;
+
+        pr_debug(" -> %s:%d\n", __func__, __LINE__);
+
+        for (bus_index = 0; bus_index < 10; bus_index++) {
+                enum ps3_bus_type bus_type;
+                unsigned int bus_id;
+                unsigned int num_dev;
+
+                result = ps3_repository_read_bus_type(bus_index, &bus_type);
+
+                if (result) {
+                        pr_debug("%s:%d read_bus_type(%u) failed\n",
+                                __func__, __LINE__, bus_index);
+                        break;
+                }
+
+                result = ps3_repository_read_bus_id(bus_index, &bus_id);
+
+                if (result) {
+                        pr_debug("%s:%d read_bus_id(%u) failed\n",
+                                __func__, __LINE__, bus_index);
+                        continue;
+                }
+
+                if (bus_index != bus_id)
+                        pr_debug("%s:%d bus_index != bus_id\n",
+                                __func__, __LINE__);
+
+                result = ps3_repository_read_bus_num_dev(bus_index, &num_dev);
+
+                if (result) {
+                        pr_debug("%s:%d read_bus_num_dev(%u) failed\n",
+                                __func__, __LINE__, bus_index);
+                        continue;
+                }
+
+                pr_debug("%s:%d bus_%u: bus_type %u, bus_id %u, num_dev %u\n",
+                        __func__, __LINE__, bus_index, bus_type, bus_id,
+                        num_dev);
+
+                dump_device_info(bus_index, num_dev);
+        }
+
+        pr_debug(" <- %s:%d\n", __func__, __LINE__);
+        return result;
+}
+#endif /* defined(DEBUG) */
+
+static int find_device(unsigned int bus_index, unsigned int num_dev,
+        unsigned int start_dev_index, enum ps3_dev_type dev_type,
+        struct ps3_repository_device *dev)
+{
+        int result = 0;
+        unsigned int dev_index;
+
+        pr_debug("%s:%d: find dev_type %u\n", __func__, __LINE__, dev_type);
+
+        dev->dev_index = UINT_MAX;
+
+        for (dev_index = start_dev_index; dev_index < num_dev; dev_index++) {
+                enum ps3_dev_type x;
+
+                result = ps3_repository_read_dev_type(bus_index, dev_index,
+                        &x);
+
+                if (result) {
+                        pr_debug("%s:%d read_dev_type failed\n",
+                                __func__, __LINE__);
+                        return result;
+                }
+
+                if (x == dev_type)
+                        break;
+        }
+
+        BUG_ON(dev_index == num_dev);
+
+        pr_debug("%s:%d: found dev_type %u at dev_index %u\n",
+                __func__, __LINE__, dev_type, dev_index);
+
+        result = ps3_repository_read_dev_id(bus_index, dev_index,
+                &dev->did.dev_id);
+
+        if (result) {
+                pr_debug("%s:%d read_dev_id failed\n",
+                        __func__, __LINE__);
+                return result;
+        }
+
+        dev->dev_index = dev_index;
+
+        pr_debug("%s:%d found: dev_id %u\n", __func__, __LINE__,
+                dev->did.dev_id);
+
+        return result;
+}
+
+int ps3_repository_find_device (enum ps3_bus_type bus_type,
+        enum ps3_dev_type dev_type,
+        const struct ps3_repository_device *start_dev,
+        struct ps3_repository_device *dev)
+{
+        int result = 0;
+        unsigned int bus_index;
+        unsigned int num_dev;
+
+        pr_debug("%s:%d: find bus_type %u, dev_type %u\n", __func__, __LINE__,
+                bus_type, dev_type);
+
+        dev->bus_index = UINT_MAX;
+
+        for (bus_index = start_dev ? start_dev->bus_index : 0; bus_index < 10;
+                bus_index++) {
+                enum ps3_bus_type x;
+
+                result = ps3_repository_read_bus_type(bus_index, &x);
+
+                if (result) {
+                        pr_debug("%s:%d read_bus_type failed\n",
+                                __func__, __LINE__);
+                        return result;
+                }
+                if (x == bus_type)
+                        break;
+        }
+
+        BUG_ON(bus_index == 10);
+
+        pr_debug("%s:%d: found bus_type %u at bus_index %u\n",
+                __func__, __LINE__, bus_type, bus_index);
+
+        result = ps3_repository_read_bus_num_dev(bus_index, &num_dev);
+
+        if (result) {
+                pr_debug("%s:%d read_bus_num_dev failed\n",
+                        __func__, __LINE__);
+                return result;
+        }
+
+        result = find_device(bus_index, num_dev, start_dev
+                ? start_dev->dev_index + 1 : 0, dev_type, dev);
+
+        if (result) {
+                pr_debug("%s:%d get_did failed\n", __func__, __LINE__);
+                return result;
+        }
+
+        result = ps3_repository_read_bus_id(bus_index, &dev->did.bus_id);
+
+        if (result) {
+                pr_debug("%s:%d read_bus_id failed\n",
+                        __func__, __LINE__);
+                return result;
+        }
+
+        dev->bus_index = bus_index;
+
+        pr_debug("%s:%d found: bus_id %u, dev_id %u\n",
+                __func__, __LINE__, dev->did.bus_id, dev->did.dev_id);
+
+        return result;
+}
+
+int ps3_repository_find_interrupt(const struct ps3_repository_device *dev,
+        enum ps3_interrupt_type intr_type, unsigned int *interrupt_id)
+{
+        int result = 0;
+        unsigned int res_index;
+
+        pr_debug("%s:%d: find intr_type %u\n", __func__, __LINE__, intr_type);
+
+        *interrupt_id = UINT_MAX;
+
+        for (res_index = 0; res_index < 10; res_index++) {
+                enum ps3_interrupt_type t;
+                unsigned int id;
+
+                result = ps3_repository_read_dev_intr(dev->bus_index,
+                        dev->dev_index, res_index, &t, &id);
+
+                if (result) {
+                        pr_debug("%s:%d read_dev_intr failed\n",
+                                __func__, __LINE__);
+                        return result;
+                }
+
+                if (t == intr_type) {
+                        *interrupt_id = id;
+                        break;
+                }
+        }
+
+        BUG_ON(res_index == 10);
+
+        pr_debug("%s:%d: found intr_type %u at res_index %u\n",
+                __func__, __LINE__, intr_type, res_index);
+
+        return result;
+}
+
+int ps3_repository_find_region(const struct ps3_repository_device *dev,
+        enum ps3_region_type reg_type, u64 *bus_addr, u64 *len)
+{
+        int result = 0;
+        unsigned int res_index;
+
+        pr_debug("%s:%d: find reg_type %u\n", __func__, __LINE__, reg_type);
+
+        *bus_addr = *len = 0;
+
+        for (res_index = 0; res_index < 10; res_index++) {
+                enum ps3_region_type t;
+                u64 a;
+                u64 l;
+
+                result = ps3_repository_read_dev_reg(dev->bus_index,
+                        dev->dev_index, res_index, &t, &a, &l);
+
+                if (result) {
+                        pr_debug("%s:%d read_dev_reg failed\n",
+                                __func__, __LINE__);
+                        return result;
+                }
+
+                if (t == reg_type) {
+                        *bus_addr = a;
+                        *len = l;
+                        break;
+                }
+        }
+
+        BUG_ON(res_index == 10);
+
+        pr_debug("%s:%d: found reg_type %u at res_index %u\n",
+                __func__, __LINE__, reg_type, res_index);
+
+        return result;
+}
+
+int ps3_repository_read_rm_size(unsigned int ppe_id, u64 *rm_size)
+{
+        return read_node(PS3_LPAR_ID_CURRENT,
+                make_first_field("bi", 0),
+                make_field("pu", 0),
+                ppe_id,
+                make_field("rm_size", 0),
+                rm_size, 0);
+}
+
+int ps3_repository_read_region_total(u64 *region_total)
+{
+        return read_node(PS3_LPAR_ID_CURRENT,
+                make_first_field("bi", 0),
+                make_field("rgntotal", 0),
+                0, 0,
+                region_total, 0);
+}
+
+/**
+ * ps3_repository_read_mm_info - Read mm info for single pu system.
+ * @rm_base: Real mode memory base address.
+ * @rm_size: Real mode memory size.
+ * @region_total: Maximum memory region size.
+ */
+
+int ps3_repository_read_mm_info(u64 *rm_base, u64 *rm_size, u64 *region_total)
+{
+        int result;
+        u64 ppe_id;
+
+        lv1_get_logical_ppe_id(&ppe_id);
+        *rm_base = 0;
+        result = ps3_repository_read_rm_size(ppe_id, rm_size);
+        return result ? result
+                : ps3_repository_read_region_total(region_total);
+}
+
+/**
+ * ps3_repository_read_num_spu_reserved - Number of physical spus reserved.
+ * @num_spu: Number of physical spus.
+ */
+
+int ps3_repository_read_num_spu_reserved(unsigned int *num_spu_reserved)
+{
+        int result;
+        u64 v1;
+
+        result = read_node(PS3_LPAR_ID_CURRENT,
+                make_first_field("bi", 0),
+                make_field("spun", 0),
+                0, 0,
+                &v1, 0);
+        *num_spu_reserved = v1;
+        return result;
+}
+
+/**
+ * ps3_repository_read_num_spu_resource_id - Number of spu resource reservations.
+ * @num_resource_id: Number of spu resource ids.
+ */
+
+int ps3_repository_read_num_spu_resource_id(unsigned int *num_resource_id)
+{
+        int result;
+        u64 v1;
+
+        result = read_node(PS3_LPAR_ID_CURRENT,
+                make_first_field("bi", 0),
+                make_field("spursvn", 0),
+                0, 0,
+                &v1, 0);
+        *num_resource_id = v1;
+        return result;
+}
+
+/**
+ * ps3_repository_read_spu_resource_id - spu resource reservation id value.
+ * @res_index: Resource reservation index.
+ * @resource_type: Resource reservation type.
+ * @resource_id: Resource reservation id.
+ */
+
+int ps3_repository_read_spu_resource_id(unsigned int res_index,
+        enum ps3_spu_resource_type* resource_type, unsigned int *resource_id)
+{
+        int result;
+        u64 v1;
+        u64 v2;
+
+        result = read_node(PS3_LPAR_ID_CURRENT,
+                make_first_field("bi", 0),
+                make_field("spursv", 0),
+                res_index,
+                0,
+                &v1, &v2);
+        *resource_type = v1;
+        *resource_id = v2;
+        return result;
+}
+
+int ps3_repository_read_boot_dat_address(u64 *address)
+{
+        return read_node(PS3_LPAR_ID_CURRENT,
+                make_first_field("bi", 0),
+                make_field("boot_dat", 0),
+                make_field("address", 0),
+                0,
+                address, 0);
+}
+
+int ps3_repository_read_boot_dat_size(unsigned int *size)
+{
+        int result;
+        u64 v1;
+
+        result = read_node(PS3_LPAR_ID_CURRENT,
+                make_first_field("bi", 0),
+                make_field("boot_dat", 0),
+                make_field("size", 0),
+                0,
+                &v1, 0);
+        *size = v1;
+        return result;
+}
+
+/**
+  * ps3_repository_read_boot_dat_info - Get address and size of cell_ext_os_area.
+  * address: lpar address of cell_ext_os_area
+  * @size: size of cell_ext_os_area
+  */
+
+int ps3_repository_read_boot_dat_info(u64 *lpar_addr, unsigned int *size)
+{
+        int result;
+
+        *size = 0;
+        result = ps3_repository_read_boot_dat_address(lpar_addr);
+        return result ? result
+                : ps3_repository_read_boot_dat_size(size);
+}
+
+int ps3_repository_read_num_be(unsigned int *num_be)
+{
+        int result;
+        u64 v1;
+
+        result = read_node(PS3_LPAR_ID_PME,
+                make_first_field("ben", 0),
+                0,
+                0,
+                0,
+                &v1, 0);
+        *num_be = v1;
+        return result;
+}
+
+int ps3_repository_read_be_node_id(unsigned int be_index, u64 *node_id)
+{
+        return read_node(PS3_LPAR_ID_PME,
+                make_first_field("be", be_index),
+                0,
+                0,
+                0,
+                node_id, 0);
+}
+
+int ps3_repository_read_tb_freq(u64 node_id, u64 *tb_freq)
+{
+        return read_node(PS3_LPAR_ID_PME,
+                make_first_field("be", 0),
+                node_id,
+                make_field("clock", 0),
+                0,
+                tb_freq, 0);
+}
+
+int ps3_repository_read_be_tb_freq(unsigned int be_index, u64 *tb_freq)
+{
+        int result;
+        u64 node_id;
+
+        *tb_freq = 0;
+        result = ps3_repository_read_be_node_id(0, &node_id);
+        return result ? result
+                : ps3_repository_read_tb_freq(node_id, tb_freq);
+}
diff --git a/arch/powerpc/platforms/ps3/setup.c b/arch/powerpc/platforms/ps3/setup.c
new file mode 100644
index 000000000000..d8b5cadbe80e
--- /dev/null
+++ b/arch/powerpc/platforms/ps3/setup.c
@@ -0,0 +1,173 @@
+/*
+ *  PS3 platform setup routines.
+ *
+ *  Copyright (C) 2006 Sony Computer Entertainment Inc.
+ *  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/kernel.h>
+#include <linux/delay.h>
+#include <linux/fs.h>
+#include <linux/root_dev.h>
+#include <linux/console.h>
+#include <linux/kexec.h>
+
+#include <asm/machdep.h>
+#include <asm/firmware.h>
+#include <asm/time.h>
+#include <asm/iommu.h>
+#include <asm/udbg.h>
+#include <asm/prom.h>
+#include <asm/lv1call.h>
+
+#include "platform.h"
+
+#if defined(DEBUG)
+#define DBG(fmt...) udbg_printf(fmt)
+#else
+#define DBG(fmt...) do{if(0)printk(fmt);}while(0)
+#endif
+
+static void ps3_show_cpuinfo(struct seq_file *m)
+{
+        seq_printf(m, "machine\t\t: %s\n", ppc_md.name);
+}
+
+static void ps3_power_save(void)
+{
+        /*
+         * lv1_pause() puts the PPE thread into inactive state until an
+         * irq on an unmasked plug exists. MSR[EE] has no effect.
+         * flags: 0 = wake on DEC interrupt, 1 = ignore DEC interrupt.
+         */
+
+        lv1_pause(0);
+}
+
+static void ps3_panic(char *str)
+{
+        DBG("%s:%d %s\n", __func__, __LINE__, str);
+
+#ifdef CONFIG_SMP
+        smp_send_stop();
+#endif
+        printk("\n");
+        printk("   System does not reboot automatically.\n");
+        printk("   Please press POWER button.\n");
+        printk("\n");
+
+        for (;;) ;
+}
+
+static void __init ps3_setup_arch(void)
+{
+        DBG(" -> %s:%d\n", __func__, __LINE__);
+
+        ps3_spu_set_platform();
+        ps3_map_htab();
+
+#ifdef CONFIG_SMP
+        smp_init_ps3();
+#endif
+
+#ifdef CONFIG_DUMMY_CONSOLE
+        conswitchp = &dummy_con;
+#endif
+
+        ppc_md.power_save = ps3_power_save;
+
+        DBG(" <- %s:%d\n", __func__, __LINE__);
+}
+
+static void __init ps3_progress(char *s, unsigned short hex)
+{
+        printk("*** %04x : %s\n", hex, s ? s : "");
+}
+
+static int __init ps3_probe(void)
+{
+        unsigned long htab_size;
+        unsigned long dt_root;
+
+        DBG(" -> %s:%d\n", __func__, __LINE__);
+
+        dt_root = of_get_flat_dt_root();
+        if (!of_flat_dt_is_compatible(dt_root, "PS3"))
+                return 0;
+
+        powerpc_firmware_features |= FW_FEATURE_PS3_POSSIBLE;
+
+        ps3_os_area_init();
+        ps3_mm_init();
+        ps3_mm_vas_create(&htab_size);
+        ps3_hpte_init(htab_size);
+
+        DBG(" <- %s:%d\n", __func__, __LINE__);
+        return 1;
+}
+
+#if defined(CONFIG_KEXEC)
+static void ps3_kexec_cpu_down(int crash_shutdown, int secondary)
+{
+        DBG(" -> %s:%d\n", __func__, __LINE__);
+
+        if (secondary) {
+                int cpu;
+                for_each_online_cpu(cpu)
+                        if (cpu)
+                                ps3_smp_cleanup_cpu(cpu);
+        } else
+                ps3_smp_cleanup_cpu(0);
+
+        DBG(" <- %s:%d\n", __func__, __LINE__);
+}
+
+static void ps3_machine_kexec(struct kimage *image)
+{
+        unsigned long ppe_id;
+
+        DBG(" -> %s:%d\n", __func__, __LINE__);
+
+        lv1_get_logical_ppe_id(&ppe_id);
+        lv1_configure_irq_state_bitmap(ppe_id, 0, 0);
+        ps3_mm_shutdown();
+        ps3_mm_vas_destroy();
+
+        default_machine_kexec(image);
+
+        DBG(" <- %s:%d\n", __func__, __LINE__);
+}
+#endif
+
+define_machine(ps3) {
+        .name                           = "PS3",
+        .probe                          = ps3_probe,
+        .setup_arch                     = ps3_setup_arch,
+        .show_cpuinfo                   = ps3_show_cpuinfo,
+        .init_IRQ                       = ps3_init_IRQ,
+        .panic                          = ps3_panic,
+        .get_boot_time                  = ps3_get_boot_time,
+        .set_rtc_time                   = ps3_set_rtc_time,
+        .get_rtc_time                   = ps3_get_rtc_time,
+        .calibrate_decr                 = ps3_calibrate_decr,
+        .progress                       = ps3_progress,
+#if defined(CONFIG_KEXEC)
+        .kexec_cpu_down                 = ps3_kexec_cpu_down,
+        .machine_kexec                  = ps3_machine_kexec,
+        .machine_kexec_prepare          = default_machine_kexec_prepare,
+        .machine_crash_shutdown         = default_machine_crash_shutdown,
+#endif
+};
diff --git a/arch/powerpc/platforms/ps3/smp.c b/arch/powerpc/platforms/ps3/smp.c
new file mode 100644
index 000000000000..11d2080607ed
--- /dev/null
+++ b/arch/powerpc/platforms/ps3/smp.c
@@ -0,0 +1,158 @@
+/*
+ *  PS3 SMP routines.
+ *
+ *  Copyright (C) 2006 Sony Computer Entertainment Inc.
+ *  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/kernel.h>
+#include <linux/smp.h>
+
+#include <asm/machdep.h>
+#include <asm/udbg.h>
+#include <asm/ps3.h>
+
+#include "platform.h"
+
+#if defined(DEBUG)
+#define DBG(fmt...) udbg_printf(fmt)
+#else
+#define DBG(fmt...) do{if(0)printk(fmt);}while(0)
+#endif
+
+static irqreturn_t ipi_function_handler(int irq, void *msg)
+{
+        smp_message_recv((int)(long)msg);
+        return IRQ_HANDLED;
+}
+
+/**
+  * virqs - a per cpu array of virqs for ipi use
+  */
+
+#define MSG_COUNT 4
+static DEFINE_PER_CPU(unsigned int, virqs[MSG_COUNT]);
+
+static const char *names[MSG_COUNT] = {
+        "ipi call",
+        "ipi reschedule",
+        "ipi migrate",
+        "ipi debug brk"
+};
+
+static void do_message_pass(int target, int msg)
+{
+        int result;
+        unsigned int virq;
+
+        if (msg >= MSG_COUNT) {
+                DBG("%s:%d: bad msg: %d\n", __func__, __LINE__, msg);
+                return;
+        }
+
+        virq = per_cpu(virqs, target)[msg];
+        result = ps3_send_event_locally(virq);
+
+        if (result)
+                DBG("%s:%d: ps3_send_event_locally(%d, %d) failed"
+                        " (%d)\n", __func__, __LINE__, target, msg, result);
+}
+
+static void ps3_smp_message_pass(int target, int msg)
+{
+        int cpu;
+
+        if (target < NR_CPUS)
+                do_message_pass(target, msg);
+        else if (target == MSG_ALL_BUT_SELF) {
+                for_each_online_cpu(cpu)
+                        if (cpu != smp_processor_id())
+                                do_message_pass(cpu, msg);
+        } else {
+                for_each_online_cpu(cpu)
+                        do_message_pass(cpu, msg);
+        }
+}
+
+static int ps3_smp_probe(void)
+{
+        return 2;
+}
+
+static void __init ps3_smp_setup_cpu(int cpu)
+{
+        int result;
+        unsigned int *virqs = per_cpu(virqs, cpu);
+        int i;
+
+        DBG(" -> %s:%d: (%d)\n", __func__, __LINE__, cpu);
+
+        /*
+         * Check assumptions on virqs[] indexing. If this
+         * check fails, then a different mapping of PPC_MSG_
+         * to index needs to be setup.
+         */
+
+        BUILD_BUG_ON(PPC_MSG_CALL_FUNCTION  != 0);
+        BUILD_BUG_ON(PPC_MSG_RESCHEDULE     != 1);
+        BUILD_BUG_ON(PPC_MSG_DEBUGGER_BREAK != 3);
+
+        for (i = 0; i < MSG_COUNT; i++) {
+                result = ps3_alloc_event_irq(&virqs[i]);
+
+                if (result)
+                        continue;
+
+                DBG("%s:%d: (%d, %d) => virq %u\n",
+                        __func__, __LINE__, cpu, i, virqs[i]);
+
+
+                request_irq(virqs[i], ipi_function_handler, IRQF_DISABLED,
+                        names[i], (void*)(long)i);
+        }
+
+        ps3_register_ipi_debug_brk(cpu, virqs[PPC_MSG_DEBUGGER_BREAK]);
+
+        DBG(" <- %s:%d: (%d)\n", __func__, __LINE__, cpu);
+}
+
+void ps3_smp_cleanup_cpu(int cpu)
+{
+        unsigned int *virqs = per_cpu(virqs, cpu);
+        int i;
+
+        DBG(" -> %s:%d: (%d)\n", __func__, __LINE__, cpu);
+        for (i = 0; i < MSG_COUNT; i++) {
+                ps3_free_event_irq(virqs[i]);
+                free_irq(virqs[i], (void*)(long)i);
+                virqs[i] = NO_IRQ;
+        }
+        DBG(" <- %s:%d: (%d)\n", __func__, __LINE__, cpu);
+}
+
+static struct smp_ops_t ps3_smp_ops = {
+        .probe          = ps3_smp_probe,
+        .message_pass   = ps3_smp_message_pass,
+        .kick_cpu       = smp_generic_kick_cpu,
+        .setup_cpu      = ps3_smp_setup_cpu,
+};
+
+void smp_init_ps3(void)
+{
+        DBG(" -> %s\n", __func__);
+        smp_ops = &ps3_smp_ops;
+        DBG(" <- %s\n", __func__);
+}
diff --git a/arch/powerpc/platforms/ps3/spu.c b/arch/powerpc/platforms/ps3/spu.c
new file mode 100644
index 000000000000..644532c3b7c4
--- /dev/null
+++ b/arch/powerpc/platforms/ps3/spu.c
@@ -0,0 +1,613 @@
+/*
+ *  PS3 Platform spu routines.
+ *
+ *  Copyright (C) 2006 Sony Computer Entertainment Inc.
+ *  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/kernel.h>
+#include <linux/init.h>
+#include <linux/mmzone.h>
+#include <linux/io.h>
+#include <linux/mm.h>
+
+#include <asm/spu.h>
+#include <asm/spu_priv1.h>
+#include <asm/ps3.h>
+#include <asm/lv1call.h>
+
+/* spu_management_ops */
+
+/**
+ * enum spe_type - Type of spe to create.
+ * @spe_type_logical: Standard logical spe.
+ *
+ * For use with lv1_construct_logical_spe().  The current HV does not support
+ * any types other than those listed.
+ */
+
+enum spe_type {
+        SPE_TYPE_LOGICAL = 0,
+};
+
+/**
+ * struct spe_shadow - logical spe shadow register area.
+ *
+ * Read-only shadow of spe registers.
+ */
+
+struct spe_shadow {
+        u8 padding_0000[0x0140];
+        u64 int_status_class0_RW;       /* 0x0140 */
+        u64 int_status_class1_RW;       /* 0x0148 */
+        u64 int_status_class2_RW;       /* 0x0150 */
+        u8 padding_0158[0x0610-0x0158];
+        u64 mfc_dsisr_RW;               /* 0x0610 */
+        u8 padding_0618[0x0620-0x0618];
+        u64 mfc_dar_RW;                 /* 0x0620 */
+        u8 padding_0628[0x0800-0x0628];
+        u64 mfc_dsipr_R;                /* 0x0800 */
+        u8 padding_0808[0x0810-0x0808];
+        u64 mfc_lscrr_R;                /* 0x0810 */
+        u8 padding_0818[0x0c00-0x0818];
+        u64 mfc_cer_R;                  /* 0x0c00 */
+        u8 padding_0c08[0x0f00-0x0c08];
+        u64 spe_execution_status;       /* 0x0f00 */
+        u8 padding_0f08[0x1000-0x0f08];
+} __attribute__ ((packed));
+
+
+/**
+ * enum spe_ex_state - Logical spe execution state.
+ * @spe_ex_state_unexecutable: Uninitialized.
+ * @spe_ex_state_executable: Enabled, not ready.
+ * @spe_ex_state_executed: Ready for use.
+ *
+ * The execution state (status) of the logical spe as reported in
+ * struct spe_shadow:spe_execution_status.
+ */
+
+enum spe_ex_state {
+        SPE_EX_STATE_UNEXECUTABLE = 0,
+        SPE_EX_STATE_EXECUTABLE = 2,
+        SPE_EX_STATE_EXECUTED = 3,
+};
+
+/**
+ * struct priv1_cache - Cached values of priv1 registers.
+ * @masks[]: Array of cached spe interrupt masks, indexed by class.
+ * @sr1: Cached mfc_sr1 register.
+ * @tclass_id: Cached mfc_tclass_id register.
+ */
+
+struct priv1_cache {
+        u64 masks[3];
+        u64 sr1;
+        u64 tclass_id;
+};
+
+/**
+ * struct spu_pdata - Platform state variables.
+ * @spe_id: HV spe id returned by lv1_construct_logical_spe().
+ * @resource_id: HV spe resource id returned by
+ *      ps3_repository_read_spe_resource_id().
+ * @priv2_addr: lpar address of spe priv2 area returned by
+ *      lv1_construct_logical_spe().
+ * @shadow_addr: lpar address of spe register shadow area returned by
+ *      lv1_construct_logical_spe().
+ * @shadow: Virtual (ioremap) address of spe register shadow area.
+ * @cache: Cached values of priv1 registers.
+ */
+
+struct spu_pdata {
+        u64 spe_id;
+        u64 resource_id;
+        u64 priv2_addr;
+        u64 shadow_addr;
+        struct spe_shadow __iomem *shadow;
+        struct priv1_cache cache;
+};
+
+static struct spu_pdata *spu_pdata(struct spu *spu)
+{
+        return spu->pdata;
+}
+
+#define dump_areas(_a, _b, _c, _d, _e) \
+        _dump_areas(_a, _b, _c, _d, _e, __func__, __LINE__)
+static void _dump_areas(unsigned int spe_id, unsigned long priv2,
+        unsigned long problem, unsigned long ls, unsigned long shadow,
+        const char* func, int line)
+{
+        pr_debug("%s:%d: spe_id:  %xh (%u)\n", func, line, spe_id, spe_id);
+        pr_debug("%s:%d: priv2:   %lxh\n", func, line, priv2);
+        pr_debug("%s:%d: problem: %lxh\n", func, line, problem);
+        pr_debug("%s:%d: ls:      %lxh\n", func, line, ls);
+        pr_debug("%s:%d: shadow:  %lxh\n", func, line, shadow);
+}
+
+static unsigned long get_vas_id(void)
+{
+        unsigned long id;
+
+        lv1_get_logical_ppe_id(&id);
+        lv1_get_virtual_address_space_id_of_ppe(id, &id);
+
+        return id;
+}
+
+static int __init construct_spu(struct spu *spu)
+{
+        int result;
+        unsigned long unused;
+
+        result = lv1_construct_logical_spe(PAGE_SHIFT, PAGE_SHIFT, PAGE_SHIFT,
+                PAGE_SHIFT, PAGE_SHIFT, get_vas_id(), SPE_TYPE_LOGICAL,
+                &spu_pdata(spu)->priv2_addr, &spu->problem_phys,
+                &spu->local_store_phys, &unused,
+                &spu_pdata(spu)->shadow_addr,
+                &spu_pdata(spu)->spe_id);
+
+        if (result) {
+                pr_debug("%s:%d: lv1_construct_logical_spe failed: %s\n",
+                        __func__, __LINE__, ps3_result(result));
+                return result;
+        }
+
+        return result;
+}
+
+static int __init add_spu_pages(unsigned long start_addr, unsigned long size)
+{
+        int result;
+        unsigned long start_pfn;
+        unsigned long nr_pages;
+        struct pglist_data *pgdata;
+        struct zone *zone;
+
+        BUG_ON(!mem_init_done);
+
+        start_pfn = start_addr >> PAGE_SHIFT;
+        nr_pages = (size + PAGE_SIZE - 1) >> PAGE_SHIFT;
+
+        pgdata = NODE_DATA(0);
+        zone = pgdata->node_zones;
+
+        result = __add_pages(zone, start_pfn, nr_pages);
+
+        if (result)
+                pr_debug("%s:%d: __add_pages failed: (%d)\n",
+                        __func__, __LINE__, result);
+
+        return result;
+}
+
+static void spu_unmap(struct spu *spu)
+{
+        iounmap(spu->priv2);
+        iounmap(spu->problem);
+        iounmap((__force u8 __iomem *)spu->local_store);
+        iounmap(spu_pdata(spu)->shadow);
+}
+
+static int __init setup_areas(struct spu *spu)
+{
+        struct table {char* name; unsigned long addr; unsigned long size;};
+        int result;
+
+        /* setup pages */
+
+        result = add_spu_pages(spu->local_store_phys, LS_SIZE);
+        if (result)
+                goto fail_add;
+
+        result = add_spu_pages(spu->problem_phys, sizeof(struct spu_problem));
+        if (result)
+                goto fail_add;
+
+        /* ioremap */
+
+        spu_pdata(spu)->shadow = __ioremap(
+                spu_pdata(spu)->shadow_addr, sizeof(struct spe_shadow),
+                PAGE_READONLY | _PAGE_NO_CACHE | _PAGE_GUARDED);
+        if (!spu_pdata(spu)->shadow) {
+                pr_debug("%s:%d: ioremap shadow failed\n", __func__, __LINE__);
+                goto fail_ioremap;
+        }
+
+        spu->local_store = ioremap(spu->local_store_phys, LS_SIZE);
+        if (!spu->local_store) {
+                pr_debug("%s:%d: ioremap local_store failed\n",
+                        __func__, __LINE__);
+                goto fail_ioremap;
+        }
+
+        spu->problem = ioremap(spu->problem_phys,
+                sizeof(struct spu_problem));
+        if (!spu->problem) {
+                pr_debug("%s:%d: ioremap problem failed\n", __func__, __LINE__);
+                goto fail_ioremap;
+        }
+
+        spu->priv2 = ioremap(spu_pdata(spu)->priv2_addr,
+                sizeof(struct spu_priv2));
+        if (!spu->priv2) {
+                pr_debug("%s:%d: ioremap priv2 failed\n", __func__, __LINE__);
+                goto fail_ioremap;
+        }
+
+        dump_areas(spu_pdata(spu)->spe_id, spu_pdata(spu)->priv2_addr,
+                spu->problem_phys, spu->local_store_phys,
+                spu_pdata(spu)->shadow_addr);
+        dump_areas(spu_pdata(spu)->spe_id, (unsigned long)spu->priv2,
+                (unsigned long)spu->problem, (unsigned long)spu->local_store,
+                (unsigned long)spu_pdata(spu)->shadow);
+
+        return 0;
+
+fail_ioremap:
+        spu_unmap(spu);
+fail_add:
+        return result;
+}
+
+static int __init setup_interrupts(struct spu *spu)
+{
+        int result;
+
+        result = ps3_alloc_spe_irq(spu_pdata(spu)->spe_id, 0,
+                &spu->irqs[0]);
+
+        if (result)
+                goto fail_alloc_0;
+
+        result = ps3_alloc_spe_irq(spu_pdata(spu)->spe_id, 1,
+                &spu->irqs[1]);
+
+        if (result)
+                goto fail_alloc_1;
+
+        result = ps3_alloc_spe_irq(spu_pdata(spu)->spe_id, 2,
+                &spu->irqs[2]);
+
+        if (result)
+                goto fail_alloc_2;
+
+        return result;
+
+fail_alloc_2:
+        ps3_free_spe_irq(spu->irqs[1]);
+fail_alloc_1:
+        ps3_free_spe_irq(spu->irqs[0]);
+fail_alloc_0:
+        spu->irqs[0] = spu->irqs[1] = spu->irqs[2] = NO_IRQ;
+        return result;
+}
+
+static int __init enable_spu(struct spu *spu)
+{
+        int result;
+
+        result = lv1_enable_logical_spe(spu_pdata(spu)->spe_id,
+                spu_pdata(spu)->resource_id);
+
+        if (result) {
+                pr_debug("%s:%d: lv1_enable_logical_spe failed: %s\n",
+                        __func__, __LINE__, ps3_result(result));
+                goto fail_enable;
+        }
+
+        result = setup_areas(spu);
+
+        if (result)
+                goto fail_areas;
+
+        result = setup_interrupts(spu);
+
+        if (result)
+                goto fail_interrupts;
+
+        return 0;
+
+fail_interrupts:
+        spu_unmap(spu);
+fail_areas:
+        lv1_disable_logical_spe(spu_pdata(spu)->spe_id, 0);
+fail_enable:
+        return result;
+}
+
+static int ps3_destroy_spu(struct spu *spu)
+{
+        int result;
+
+        pr_debug("%s:%d spu_%d\n", __func__, __LINE__, spu->number);
+
+        result = lv1_disable_logical_spe(spu_pdata(spu)->spe_id, 0);
+        BUG_ON(result);
+
+        ps3_free_spe_irq(spu->irqs[2]);
+        ps3_free_spe_irq(spu->irqs[1]);
+        ps3_free_spe_irq(spu->irqs[0]);
+
+        spu->irqs[0] = spu->irqs[1] = spu->irqs[2] = NO_IRQ;
+
+        spu_unmap(spu);
+
+        result = lv1_destruct_logical_spe(spu_pdata(spu)->spe_id);
+        BUG_ON(result);
+
+        kfree(spu->pdata);
+        spu->pdata = NULL;
+
+        return 0;
+}
+
+static int __init ps3_create_spu(struct spu *spu, void *data)
+{
+        int result;
+
+        pr_debug("%s:%d spu_%d\n", __func__, __LINE__, spu->number);
+
+        spu->pdata = kzalloc(sizeof(struct spu_pdata),
+                GFP_KERNEL);
+
+        if (!spu->pdata) {
+                result = -ENOMEM;
+                goto fail_malloc;
+        }
+
+        spu_pdata(spu)->resource_id = (unsigned long)data;
+
+        /* Init cached reg values to HV defaults. */
+
+        spu_pdata(spu)->cache.sr1 = 0x33;
+
+        result = construct_spu(spu);
+
+        if (result)
+                goto fail_construct;
+
+        /* For now, just go ahead and enable it. */
+
+        result = enable_spu(spu);
+
+        if (result)
+                goto fail_enable;
+
+        /* Make sure the spu is in SPE_EX_STATE_EXECUTED. */
+
+        /* need something better here!!! */
+        while (in_be64(&spu_pdata(spu)->shadow->spe_execution_status)
+                != SPE_EX_STATE_EXECUTED)
+                (void)0;
+
+        return result;
+
+fail_enable:
+fail_construct:
+        ps3_destroy_spu(spu);
+fail_malloc:
+        return result;
+}
+
+static int __init ps3_enumerate_spus(int (*fn)(void *data))
+{
+        int result;
+        unsigned int num_resource_id;
+        unsigned int i;
+
+        result = ps3_repository_read_num_spu_resource_id(&num_resource_id);
+
+        pr_debug("%s:%d: num_resource_id %u\n", __func__, __LINE__,
+                num_resource_id);
+
+        /*
+         * For now, just create logical spus equal to the number
+         * of physical spus reserved for the partition.
+         */
+
+        for (i = 0; i < num_resource_id; i++) {
+                enum ps3_spu_resource_type resource_type;
+                unsigned int resource_id;
+
+                result = ps3_repository_read_spu_resource_id(i,
+                        &resource_type, &resource_id);
+
+                if (result)
+                        break;
+
+                if (resource_type == PS3_SPU_RESOURCE_TYPE_EXCLUSIVE) {
+                        result = fn((void*)(unsigned long)resource_id);
+
+                        if (result)
+                                break;
+                }
+        }
+
+        if (result)
+                printk(KERN_WARNING "%s:%d: Error initializing spus\n",
+                        __func__, __LINE__);
+
+        return result;
+}
+
+const struct spu_management_ops spu_management_ps3_ops = {
+        .enumerate_spus = ps3_enumerate_spus,
+        .create_spu = ps3_create_spu,
+        .destroy_spu = ps3_destroy_spu,
+};
+
+/* spu_priv1_ops */
+
+static void int_mask_and(struct spu *spu, int class, u64 mask)
+{
+        u64 old_mask;
+
+        /* are these serialized by caller??? */
+        old_mask = spu_int_mask_get(spu, class);
+        spu_int_mask_set(spu, class, old_mask & mask);
+}
+
+static void int_mask_or(struct spu *spu, int class, u64 mask)
+{
+        u64 old_mask;
+
+        old_mask = spu_int_mask_get(spu, class);
+        spu_int_mask_set(spu, class, old_mask | mask);
+}
+
+static void int_mask_set(struct spu *spu, int class, u64 mask)
+{
+        spu_pdata(spu)->cache.masks[class] = mask;
+        lv1_set_spe_interrupt_mask(spu_pdata(spu)->spe_id, class,
+                spu_pdata(spu)->cache.masks[class]);
+}
+
+static u64 int_mask_get(struct spu *spu, int class)
+{
+        return spu_pdata(spu)->cache.masks[class];
+}
+
+static void int_stat_clear(struct spu *spu, int class, u64 stat)
+{
+        /* Note that MFC_DSISR will be cleared when class1[MF] is set. */
+
+        lv1_clear_spe_interrupt_status(spu_pdata(spu)->spe_id, class,
+                stat, 0);
+}
+
+static u64 int_stat_get(struct spu *spu, int class)
+{
+        u64 stat;
+
+        lv1_get_spe_interrupt_status(spu_pdata(spu)->spe_id, class, &stat);
+        return stat;
+}
+
+static void cpu_affinity_set(struct spu *spu, int cpu)
+{
+        /* No support. */
+}
+
+static u64 mfc_dar_get(struct spu *spu)
+{
+        return in_be64(&spu_pdata(spu)->shadow->mfc_dar_RW);
+}
+
+static void mfc_dsisr_set(struct spu *spu, u64 dsisr)
+{
+        /* Nothing to do, cleared in int_stat_clear(). */
+}
+
+static u64 mfc_dsisr_get(struct spu *spu)
+{
+        return in_be64(&spu_pdata(spu)->shadow->mfc_dsisr_RW);
+}
+
+static void mfc_sdr_setup(struct spu *spu)
+{
+        /* Nothing to do. */
+}
+
+static void mfc_sr1_set(struct spu *spu, u64 sr1)
+{
+        /* Check bits allowed by HV. */
+
+        static const u64 allowed = ~(MFC_STATE1_LOCAL_STORAGE_DECODE_MASK
+                | MFC_STATE1_PROBLEM_STATE_MASK);
+
+        BUG_ON((sr1 & allowed) != (spu_pdata(spu)->cache.sr1 & allowed));
+
+        spu_pdata(spu)->cache.sr1 = sr1;
+        lv1_set_spe_privilege_state_area_1_register(
+                spu_pdata(spu)->spe_id,
+                offsetof(struct spu_priv1, mfc_sr1_RW),
+                spu_pdata(spu)->cache.sr1);
+}
+
+static u64 mfc_sr1_get(struct spu *spu)
+{
+        return spu_pdata(spu)->cache.sr1;
+}
+
+static void mfc_tclass_id_set(struct spu *spu, u64 tclass_id)
+{
+        spu_pdata(spu)->cache.tclass_id = tclass_id;
+        lv1_set_spe_privilege_state_area_1_register(
+                spu_pdata(spu)->spe_id,
+                offsetof(struct spu_priv1, mfc_tclass_id_RW),
+                spu_pdata(spu)->cache.tclass_id);
+}
+
+static u64 mfc_tclass_id_get(struct spu *spu)
+{
+        return spu_pdata(spu)->cache.tclass_id;
+}
+
+static void tlb_invalidate(struct spu *spu)
+{
+        /* Nothing to do. */
+}
+
+static void resource_allocation_groupID_set(struct spu *spu, u64 id)
+{
+        /* No support. */
+}
+
+static u64 resource_allocation_groupID_get(struct spu *spu)
+{
+        return 0; /* No support. */
+}
+
+static void resource_allocation_enable_set(struct spu *spu, u64 enable)
+{
+        /* No support. */
+}
+
+static u64 resource_allocation_enable_get(struct spu *spu)
+{
+        return 0; /* No support. */
+}
+
+const struct spu_priv1_ops spu_priv1_ps3_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_set = mfc_dsisr_set,
+        .mfc_dsisr_get = mfc_dsisr_get,
+        .mfc_sdr_setup = mfc_sdr_setup,
+        .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,
+};
+
+void ps3_spu_set_platform(void)
+{
+        spu_priv1_ops = &spu_priv1_ps3_ops;
+        spu_management_ops = &spu_management_ps3_ops;
+}
diff --git a/arch/powerpc/platforms/ps3/time.c b/arch/powerpc/platforms/ps3/time.c
new file mode 100644
index 000000000000..1bae8b19b363
--- /dev/null
+++ b/arch/powerpc/platforms/ps3/time.c
@@ -0,0 +1,104 @@
+/*
+ *  PS3 time and rtc routines.
+ *
+ *  Copyright (C) 2006 Sony Computer Entertainment Inc.
+ *  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/kernel.h>
+
+#include <asm/rtc.h>
+#include <asm/lv1call.h>
+#include <asm/ps3.h>
+
+#include "platform.h"
+
+#define dump_tm(_a) _dump_tm(_a, __func__, __LINE__)
+static void _dump_tm(const struct rtc_time *tm, const char* func, int line)
+{
+        pr_debug("%s:%d tm_sec  %d\n", func, line, tm->tm_sec);
+        pr_debug("%s:%d tm_min  %d\n", func, line, tm->tm_min);
+        pr_debug("%s:%d tm_hour %d\n", func, line, tm->tm_hour);
+        pr_debug("%s:%d tm_mday %d\n", func, line, tm->tm_mday);
+        pr_debug("%s:%d tm_mon  %d\n", func, line, tm->tm_mon);
+        pr_debug("%s:%d tm_year %d\n", func, line, tm->tm_year);
+        pr_debug("%s:%d tm_wday %d\n", func, line, tm->tm_wday);
+}
+
+#define dump_time(_a) _dump_time(_a, __func__, __LINE__)
+static void __attribute__ ((unused)) _dump_time(int time, const char* func,
+        int line)
+{
+        struct rtc_time tm;
+
+        to_tm(time, &tm);
+
+        pr_debug("%s:%d time    %d\n", func, line, time);
+        _dump_tm(&tm, func, line);
+}
+
+/**
+ * rtc_shift - Difference in seconds between 1970 and the ps3 rtc value.
+ */
+
+static s64 rtc_shift;
+
+void __init ps3_calibrate_decr(void)
+{
+        int result;
+        u64 tmp;
+
+        result = ps3_repository_read_be_tb_freq(0, &tmp);
+        BUG_ON(result);
+
+        ppc_tb_freq = tmp;
+        ppc_proc_freq = ppc_tb_freq * 40;
+
+        rtc_shift = ps3_os_area_rtc_diff();
+}
+
+static u64 read_rtc(void)
+{
+        int result;
+        u64 rtc_val;
+        u64 tb_val;
+
+        result = lv1_get_rtc(&rtc_val, &tb_val);
+        BUG_ON(result);
+
+        return rtc_val;
+}
+
+int ps3_set_rtc_time(struct rtc_time *tm)
+{
+        u64 now = mktime(tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
+                tm->tm_hour, tm->tm_min, tm->tm_sec);
+
+        rtc_shift = now - read_rtc();
+        return 0;
+}
+
+void ps3_get_rtc_time(struct rtc_time *tm)
+{
+        to_tm(read_rtc() + rtc_shift, tm);
+        tm->tm_year -= 1900;
+        tm->tm_mon -= 1;
+}
+
+unsigned long __init ps3_get_boot_time(void)
+{
+        return read_rtc() + rtc_shift;
+}
diff --git a/arch/powerpc/platforms/pseries/Makefile b/arch/powerpc/platforms/pseries/Makefile
index 997243a91be8..69590fbf83da 100644
--- a/arch/powerpc/platforms/pseries/Makefile
+++ b/arch/powerpc/platforms/pseries/Makefile
@@ -10,6 +10,8 @@ obj-$(CONFIG_XICS)	+= xics.o
 obj-$(CONFIG_SCANLOG)   += scanlog.o
 obj-$(CONFIG_EEH)       += eeh.o eeh_cache.o eeh_driver.o eeh_event.o
 
+obj-$(CONFIG_HOTPLUG_CPU)       += hotplug-cpu.o
+
 obj-$(CONFIG_HVC_CONSOLE)       += hvconsole.o
 obj-$(CONFIG_HVCS)              += hvcserver.o
 obj-$(CONFIG_HCALL_STATS)       += hvCall_inst.o
diff --git a/arch/powerpc/platforms/pseries/eeh.c b/arch/powerpc/platforms/pseries/eeh.c
index 3c2d63ebf787..da6e5362e7cd 100644
--- a/arch/powerpc/platforms/pseries/eeh.c
+++ b/arch/powerpc/platforms/pseries/eeh.c
@@ -337,6 +337,7 @@ int eeh_dn_check_failure(struct device_node *dn, struct pci_dev *dev)
                         printk (KERN_ERR "EEH: Device driver ignored %d bad reads, panicing\n",
                                 pdn->eeh_check_count);
                         dump_stack();
+                        msleep(5000);
                         
                         /* re-read the slot reset state */
                         if (read_slot_reset_state(pdn, rets) != 0)
diff --git a/arch/powerpc/platforms/pseries/eeh_cache.c b/arch/powerpc/platforms/pseries/eeh_cache.c
index b6b462d3c604..f2bae04424f8 100644
--- a/arch/powerpc/platforms/pseries/eeh_cache.c
+++ b/arch/powerpc/platforms/pseries/eeh_cache.c
@@ -153,7 +153,7 @@ pci_addr_cache_insert(struct pci_dev *dev, unsigned long alo,
                         return piar;
                 }
         }
-        piar = (struct pci_io_addr_range *)kmalloc(sizeof(struct pci_io_addr_range), GFP_ATOMIC);
+        piar = kmalloc(sizeof(struct pci_io_addr_range), GFP_ATOMIC);
         if (!piar)
                 return NULL;
 
diff --git a/arch/powerpc/platforms/pseries/eeh_driver.c b/arch/powerpc/platforms/pseries/eeh_driver.c
index c2bc9904f1cb..cbd6b0711ab4 100644
--- a/arch/powerpc/platforms/pseries/eeh_driver.c
+++ b/arch/powerpc/platforms/pseries/eeh_driver.c
@@ -170,14 +170,19 @@ static void eeh_report_reset(struct pci_dev *dev, void *userdata)
 static void eeh_report_resume(struct pci_dev *dev, void *userdata)
 {
         struct pci_driver *driver = dev->driver;
+        struct device_node *dn = pci_device_to_OF_node(dev);
 
         dev->error_state = pci_channel_io_normal;
 
         if (!driver)
                 return;
-        if (!driver->err_handler)
-                return;
-        if (!driver->err_handler->resume)
+
+        if ((PCI_DN(dn)->eeh_mode) & EEH_MODE_IRQ_DISABLED) {
+                PCI_DN(dn)->eeh_mode &= ~EEH_MODE_IRQ_DISABLED;
+                enable_irq(dev->irq);
+        }
+        if (!driver->err_handler ||
+            !driver->err_handler->resume)
                 return;
 
         driver->err_handler->resume(dev);
@@ -407,6 +412,8 @@ struct pci_dn * handle_eeh_events (struct eeh_event *event)
 
                 if (rc)
                         result = PCI_ERS_RESULT_NEED_RESET;
+                else
+                        result = PCI_ERS_RESULT_RECOVERED;
         }
 
         /* If any device has a hard failure, then shut off everything. */
diff --git a/arch/powerpc/platforms/pseries/eeh_event.c b/arch/powerpc/platforms/pseries/eeh_event.c
index 137077451316..49037edf7d39 100644
--- a/arch/powerpc/platforms/pseries/eeh_event.c
+++ b/arch/powerpc/platforms/pseries/eeh_event.c
@@ -37,8 +37,8 @@
 /* EEH event workqueue setup. */
 static DEFINE_SPINLOCK(eeh_eventlist_lock);
 LIST_HEAD(eeh_eventlist);
-static void eeh_thread_launcher(void *);
-DECLARE_WORK(eeh_event_wq, eeh_thread_launcher, NULL);
+static void eeh_thread_launcher(struct work_struct *);
+DECLARE_WORK(eeh_event_wq, eeh_thread_launcher);
 
 /* Serialize reset sequences for a given pci device */
 DEFINE_MUTEX(eeh_event_mutex);
@@ -103,7 +103,7 @@ static int eeh_event_handler(void * dummy)
  * eeh_thread_launcher
  * @dummy - unused
  */
-static void eeh_thread_launcher(void *dummy)
+static void eeh_thread_launcher(struct work_struct *dummy)
 {
         if (kernel_thread(eeh_event_handler, NULL, CLONE_KERNEL) < 0)
                 printk(KERN_ERR "Failed to start EEH daemon\n");
diff --git a/arch/powerpc/platforms/pseries/hotplug-cpu.c b/arch/powerpc/platforms/pseries/hotplug-cpu.c
new file mode 100644
index 000000000000..f460b9cbfd46
--- /dev/null
+++ b/arch/powerpc/platforms/pseries/hotplug-cpu.c
@@ -0,0 +1,275 @@
+/*
+ * pseries CPU Hotplug infrastructure.
+ *
+ * Split out from arch/powerpc/platforms/pseries/setup.c
+ *  arch/powerpc/kernel/rtas.c, and arch/powerpc/platforms/pseries/smp.c
+ *
+ * Peter Bergner, IBM   March 2001.
+ * Copyright (C) 2001 IBM.
+ * Dave Engebretsen, Peter Bergner, and
+ * Mike Corrigan {engebret|bergner|mikec}@us.ibm.com
+ * Plus various changes from other IBM teams...
+ *
+ * Copyright (C) 2006 Michael Ellerman, 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.
+ */
+
+#include <linux/kernel.h>
+#include <linux/delay.h>
+#include <linux/cpu.h>
+#include <asm/system.h>
+#include <asm/prom.h>
+#include <asm/rtas.h>
+#include <asm/firmware.h>
+#include <asm/machdep.h>
+#include <asm/vdso_datapage.h>
+#include <asm/pSeries_reconfig.h>
+#include "xics.h"
+
+/* This version can't take the spinlock, because it never returns */
+static struct rtas_args rtas_stop_self_args = {
+        .token = RTAS_UNKNOWN_SERVICE,
+        .nargs = 0,
+        .nret = 1,
+        .rets = &rtas_stop_self_args.args[0],
+};
+
+static void rtas_stop_self(void)
+{
+        struct rtas_args *args = &rtas_stop_self_args;
+
+        local_irq_disable();
+
+        BUG_ON(args->token == RTAS_UNKNOWN_SERVICE);
+
+        printk("cpu %u (hwid %u) Ready to die...\n",
+               smp_processor_id(), hard_smp_processor_id());
+        enter_rtas(__pa(args));
+
+        panic("Alas, I survived.\n");
+}
+
+static void pseries_mach_cpu_die(void)
+{
+        local_irq_disable();
+        idle_task_exit();
+        xics_teardown_cpu(0);
+        rtas_stop_self();
+        /* Should never get here... */
+        BUG();
+        for(;;);
+}
+
+static int qcss_tok;    /* query-cpu-stopped-state token */
+
+/* Get state of physical CPU.
+ * Return codes:
+ *      0       - The processor is in the RTAS stopped state
+ *      1       - stop-self is in progress
+ *      2       - The processor is not in the RTAS stopped state
+ *      -1      - Hardware Error
+ *      -2      - Hardware Busy, Try again later.
+ */
+static int query_cpu_stopped(unsigned int pcpu)
+{
+        int cpu_status, status;
+
+        status = rtas_call(qcss_tok, 1, 2, &cpu_status, pcpu);
+        if (status != 0) {
+                printk(KERN_ERR
+                       "RTAS query-cpu-stopped-state failed: %i\n", status);
+                return status;
+        }
+
+        return cpu_status;
+}
+
+static int pseries_cpu_disable(void)
+{
+        int cpu = smp_processor_id();
+
+        cpu_clear(cpu, cpu_online_map);
+        vdso_data->processorCount--;
+
+        /*fix boot_cpuid here*/
+        if (cpu == boot_cpuid)
+                boot_cpuid = any_online_cpu(cpu_online_map);
+
+        /* FIXME: abstract this to not be platform specific later on */
+        xics_migrate_irqs_away();
+        return 0;
+}
+
+static void pseries_cpu_die(unsigned int cpu)
+{
+        int tries;
+        int cpu_status;
+        unsigned int pcpu = get_hard_smp_processor_id(cpu);
+
+        for (tries = 0; tries < 25; tries++) {
+                cpu_status = query_cpu_stopped(pcpu);
+                if (cpu_status == 0 || cpu_status == -1)
+                        break;
+                msleep(200);
+        }
+        if (cpu_status != 0) {
+                printk("Querying DEAD? cpu %i (%i) shows %i\n",
+                       cpu, pcpu, cpu_status);
+        }
+
+        /* Isolation and deallocation are definatly done by
+         * drslot_chrp_cpu.  If they were not they would be
+         * done here.  Change isolate state to Isolate and
+         * change allocation-state to Unusable.
+         */
+        paca[cpu].cpu_start = 0;
+}
+
+/*
+ * Update cpu_present_map and paca(s) for a new cpu node.  The wrinkle
+ * here is that a cpu device node may represent up to two logical cpus
+ * in the SMT case.  We must honor the assumption in other code that
+ * the logical ids for sibling SMT threads x and y are adjacent, such
+ * that x^1 == y and y^1 == x.
+ */
+static int pseries_add_processor(struct device_node *np)
+{
+        unsigned int cpu;
+        cpumask_t candidate_map, tmp = CPU_MASK_NONE;
+        int err = -ENOSPC, len, nthreads, i;
+        const u32 *intserv;
+
+        intserv = get_property(np, "ibm,ppc-interrupt-server#s", &len);
+        if (!intserv)
+                return 0;
+
+        nthreads = len / sizeof(u32);
+        for (i = 0; i < nthreads; i++)
+                cpu_set(i, tmp);
+
+        lock_cpu_hotplug();
+
+        BUG_ON(!cpus_subset(cpu_present_map, cpu_possible_map));
+
+        /* Get a bitmap of unoccupied slots. */
+        cpus_xor(candidate_map, cpu_possible_map, cpu_present_map);
+        if (cpus_empty(candidate_map)) {
+                /* If we get here, it most likely means that NR_CPUS is
+                 * less than the partition's max processors setting.
+                 */
+                printk(KERN_ERR "Cannot add cpu %s; this system configuration"
+                       " supports %d logical cpus.\n", np->full_name,
+                       cpus_weight(cpu_possible_map));
+                goto out_unlock;
+        }
+
+        while (!cpus_empty(tmp))
+                if (cpus_subset(tmp, candidate_map))
+                        /* Found a range where we can insert the new cpu(s) */
+                        break;
+                else
+                        cpus_shift_left(tmp, tmp, nthreads);
+
+        if (cpus_empty(tmp)) {
+                printk(KERN_ERR "Unable to find space in cpu_present_map for"
+                       " processor %s with %d thread(s)\n", np->name,
+                       nthreads);
+                goto out_unlock;
+        }
+
+        for_each_cpu_mask(cpu, tmp) {
+                BUG_ON(cpu_isset(cpu, cpu_present_map));
+                cpu_set(cpu, cpu_present_map);
+                set_hard_smp_processor_id(cpu, *intserv++);
+        }
+        err = 0;
+out_unlock:
+        unlock_cpu_hotplug();
+        return err;
+}
+
+/*
+ * Update the present map for a cpu node which is going away, and set
+ * the hard id in the paca(s) to -1 to be consistent with boot time
+ * convention for non-present cpus.
+ */
+static void pseries_remove_processor(struct device_node *np)
+{
+        unsigned int cpu;
+        int len, nthreads, i;
+        const u32 *intserv;
+
+        intserv = get_property(np, "ibm,ppc-interrupt-server#s", &len);
+        if (!intserv)
+                return;
+
+        nthreads = len / sizeof(u32);
+
+        lock_cpu_hotplug();
+        for (i = 0; i < nthreads; i++) {
+                for_each_present_cpu(cpu) {
+                        if (get_hard_smp_processor_id(cpu) != intserv[i])
+                                continue;
+                        BUG_ON(cpu_online(cpu));
+                        cpu_clear(cpu, cpu_present_map);
+                        set_hard_smp_processor_id(cpu, -1);
+                        break;
+                }
+                if (cpu == NR_CPUS)
+                        printk(KERN_WARNING "Could not find cpu to remove "
+                               "with physical id 0x%x\n", intserv[i]);
+        }
+        unlock_cpu_hotplug();
+}
+
+static int pseries_smp_notifier(struct notifier_block *nb,
+                                unsigned long action, void *node)
+{
+        int err = NOTIFY_OK;
+
+        switch (action) {
+        case PSERIES_RECONFIG_ADD:
+                if (pseries_add_processor(node))
+                        err = NOTIFY_BAD;
+                break;
+        case PSERIES_RECONFIG_REMOVE:
+                pseries_remove_processor(node);
+                break;
+        default:
+                err = NOTIFY_DONE;
+                break;
+        }
+        return err;
+}
+
+static struct notifier_block pseries_smp_nb = {
+        .notifier_call = pseries_smp_notifier,
+};
+
+static int __init pseries_cpu_hotplug_init(void)
+{
+        rtas_stop_self_args.token = rtas_token("stop-self");
+        qcss_tok = rtas_token("query-cpu-stopped-state");
+
+        if (rtas_stop_self_args.token == RTAS_UNKNOWN_SERVICE ||
+                        qcss_tok == RTAS_UNKNOWN_SERVICE) {
+                printk(KERN_INFO "CPU Hotplug not supported by firmware "
+                                "- disabling.\n");
+                return 0;
+        }
+
+        ppc_md.cpu_die = pseries_mach_cpu_die;
+        smp_ops->cpu_disable = pseries_cpu_disable;
+        smp_ops->cpu_die = pseries_cpu_die;
+
+        /* Processors can be added/removed only on LPAR */
+        if (firmware_has_feature(FW_FEATURE_LPAR))
+                pSeries_reconfig_notifier_register(&pseries_smp_nb);
+
+        return 0;
+}
+arch_initcall(pseries_cpu_hotplug_init);
diff --git a/arch/powerpc/platforms/pseries/hvCall.S b/arch/powerpc/platforms/pseries/hvCall.S
index c00cfed7af2c..5c7e38789897 100644
--- a/arch/powerpc/platforms/pseries/hvCall.S
+++ b/arch/powerpc/platforms/pseries/hvCall.S
@@ -26,7 +26,7 @@
 BEGIN_FTR_SECTION;                                              \
         mfspr   r0,SPRN_PURR;           /* get PURR and */      \
         std     r0,STK_PARM(r6)(r1);    /* save for later */    \
-END_FTR_SECTION_IFCLR(CPU_FTR_PURR);
+END_FTR_SECTION_IFSET(CPU_FTR_PURR);
         
 /*
  * postcall is performed immediately before function return which
@@ -43,7 +43,7 @@ BEGIN_FTR_SECTION;						\
         mfspr   r8,SPRN_PURR;           /* PURR after */        \
         ld      r6,STK_PARM(r6)(r1);    /* PURR before */       \
         subf    r6,r6,r8;               /* delta */             \
-END_FTR_SECTION_IFCLR(CPU_FTR_PURR);                            \
+END_FTR_SECTION_IFSET(CPU_FTR_PURR);                            \
         ld      r5,STK_PARM(r5)(r1);    /* timebase before */   \
         subf    r5,r5,r7;               /* time delta */        \
                                                                 \
@@ -66,7 +66,7 @@ BEGIN_FTR_SECTION;						\
         ld      r7,HCALL_STAT_PURR(r4); /* PURR */              \
         add     r7,r7,r6;                                       \
         std     r7,HCALL_STAT_PURR(r4);                         \
-END_FTR_SECTION_IFCLR(CPU_FTR_PURR);                            \
+END_FTR_SECTION_IFSET(CPU_FTR_PURR);                            \
 1:
 #else
 #define HCALL_INST_PRECALL
@@ -145,6 +145,7 @@ _GLOBAL(plpar_hcall9)
 
         HVSC                            /* invoke the hypervisor */
 
+        mr      r0,r12
         ld      r12,STK_PARM(r4)(r1)
         std     r4,  0(r12)
         std     r5,  8(r12)
@@ -154,7 +155,7 @@ _GLOBAL(plpar_hcall9)
         std     r9, 40(r12)
         std     r10,48(r12)
         std     r11,56(r12)
-        std     r12,64(r12)
+        std     r0, 64(r12)
 
         HCALL_INST_POSTCALL
 
diff --git a/arch/powerpc/platforms/pseries/hvCall_inst.c b/arch/powerpc/platforms/pseries/hvCall_inst.c
index 446e17d162a5..3ddc04925d50 100644
--- a/arch/powerpc/platforms/pseries/hvCall_inst.c
+++ b/arch/powerpc/platforms/pseries/hvCall_inst.c
@@ -34,7 +34,7 @@ DEFINE_PER_CPU(struct hcall_stats[HCALL_STAT_ARRAY_SIZE], hcall_stats);
  */
 static void *hc_start(struct seq_file *m, loff_t *pos)
 {
-        if ((int)*pos < HCALL_STAT_ARRAY_SIZE)
+        if ((int)*pos < (HCALL_STAT_ARRAY_SIZE-1))
                 return (void *)(unsigned long)(*pos + 1);
 
         return NULL;
@@ -57,7 +57,7 @@ static int hc_show(struct seq_file *m, void *p)
         struct hcall_stats *hs = (struct hcall_stats *)m->private;
 
         if (hs[h_num].num_calls) {
-                if (!cpu_has_feature(CPU_FTR_PURR))
+                if (cpu_has_feature(CPU_FTR_PURR))
                         seq_printf(m, "%lu %lu %lu %lu\n", h_num<<2,
                                    hs[h_num].num_calls,
                                    hs[h_num].tb_total,
@@ -85,7 +85,7 @@ static int hcall_inst_seq_open(struct inode *inode, struct file *file)
 
         rc = seq_open(file, &hcall_inst_seq_ops);
         seq = file->private_data;
-        seq->private = file->f_dentry->d_inode->i_private;
+        seq->private = file->f_path.dentry->d_inode->i_private;
 
         return rc;
 }
diff --git a/arch/powerpc/platforms/pseries/iommu.c b/arch/powerpc/platforms/pseries/iommu.c
index 556c279a789d..3c95392f4f41 100644
--- a/arch/powerpc/platforms/pseries/iommu.c
+++ b/arch/powerpc/platforms/pseries/iommu.c
@@ -309,7 +309,7 @@ static void iommu_table_setparms_lpar(struct pci_controller *phb,
         tbl->it_size = size >> IOMMU_PAGE_SHIFT;
 }
 
-static void iommu_bus_setup_pSeries(struct pci_bus *bus)
+static void pci_dma_bus_setup_pSeries(struct pci_bus *bus)
 {
         struct device_node *dn;
         struct iommu_table *tbl;
@@ -318,10 +318,9 @@ static void iommu_bus_setup_pSeries(struct pci_bus *bus)
         struct pci_dn *pci;
         int children;
 
-        DBG("iommu_bus_setup_pSeries, bus %p, bus->self %p\n", bus, bus->self);
-
         dn = pci_bus_to_OF_node(bus);
-        pci = PCI_DN(dn);
+
+        DBG("pci_dma_bus_setup_pSeries: setting up bus %s\n", dn->full_name);
 
         if (bus->self) {
                 /* This is not a root bus, any setup will be done for the
@@ -329,6 +328,7 @@ static void iommu_bus_setup_pSeries(struct pci_bus *bus)
                  */
                 return;
         }
+        pci = PCI_DN(dn);
 
         /* Check if the ISA bus on the system is under
          * this PHB.
@@ -390,17 +390,17 @@ static void iommu_bus_setup_pSeries(struct pci_bus *bus)
 }
 
 
-static void iommu_bus_setup_pSeriesLP(struct pci_bus *bus)
+static void pci_dma_bus_setup_pSeriesLP(struct pci_bus *bus)
 {
         struct iommu_table *tbl;
         struct device_node *dn, *pdn;
         struct pci_dn *ppci;
         const void *dma_window = NULL;
 
-        DBG("iommu_bus_setup_pSeriesLP, bus %p, bus->self %p\n", bus, bus->self);
-
         dn = pci_bus_to_OF_node(bus);
 
+        DBG("pci_dma_bus_setup_pSeriesLP: setting up bus %s\n", dn->full_name);
+
         /* Find nearest ibm,dma-window, walking up the device tree */
         for (pdn = dn; pdn != NULL; pdn = pdn->parent) {
                 dma_window = get_property(pdn, "ibm,dma-window", NULL);
@@ -409,11 +409,15 @@ static void iommu_bus_setup_pSeriesLP(struct pci_bus *bus)
         }
 
         if (dma_window == NULL) {
-                DBG("iommu_bus_setup_pSeriesLP: bus %s seems to have no ibm,dma-window property\n", dn->full_name);
+                DBG("  no ibm,dma-window property !\n");
                 return;
         }
 
         ppci = PCI_DN(pdn);
+
+        DBG("  parent is %s, iommu_table: 0x%p\n",
+            pdn->full_name, ppci->iommu_table);
+
         if (!ppci->iommu_table) {
                 /* Bussubno hasn't been copied yet.
                  * Do it now because iommu_table_setparms_lpar needs it.
@@ -427,6 +431,7 @@ static void iommu_bus_setup_pSeriesLP(struct pci_bus *bus)
                 iommu_table_setparms_lpar(ppci->phb, pdn, tbl, dma_window);
 
                 ppci->iommu_table = iommu_init_table(tbl, ppci->phb->node);
+                DBG("  created table: %p\n", ppci->iommu_table);
         }
 
         if (pdn != dn)
@@ -434,27 +439,27 @@ static void iommu_bus_setup_pSeriesLP(struct pci_bus *bus)
 }
 
 
-static void iommu_dev_setup_pSeries(struct pci_dev *dev)
+static void pci_dma_dev_setup_pSeries(struct pci_dev *dev)
 {
-        struct device_node *dn, *mydn;
+        struct device_node *dn;
         struct iommu_table *tbl;
 
-        DBG("iommu_dev_setup_pSeries, dev %p (%s)\n", dev, pci_name(dev));
+        DBG("pci_dma_dev_setup_pSeries: %s\n", pci_name(dev));
 
-        mydn = dn = pci_device_to_OF_node(dev);
+        dn = dev->dev.archdata.of_node;
 
         /* If we're the direct child of a root bus, then we need to allocate
          * an iommu table ourselves. The bus setup code should have setup
          * the window sizes already.
          */
         if (!dev->bus->self) {
+                struct pci_controller *phb = PCI_DN(dn)->phb;
+
                 DBG(" --> first child, no bridge. Allocating iommu table.\n");
                 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(dn)->iommu_table = iommu_init_table(tbl,
-                                                PCI_DN(dn)->phb->node);
-
+                                   phb->node);
+                iommu_table_setparms(phb, dn, tbl);
+                dev->dev.archdata.dma_data = iommu_init_table(tbl, phb->node);
                 return;
         }
 
@@ -465,11 +470,11 @@ static void iommu_dev_setup_pSeries(struct pci_dev *dev)
         while (dn && PCI_DN(dn) && PCI_DN(dn)->iommu_table == NULL)
                 dn = dn->parent;
 
-        if (dn && PCI_DN(dn)) {
-                PCI_DN(mydn)->iommu_table = PCI_DN(dn)->iommu_table;
-        } else {
-                DBG("iommu_dev_setup_pSeries, dev %p (%s) has no iommu table\n", dev, pci_name(dev));
-        }
+        if (dn && PCI_DN(dn))
+                dev->dev.archdata.dma_data = PCI_DN(dn)->iommu_table;
+        else
+                printk(KERN_WARNING "iommu: Device %s has no iommu table\n",
+                       pci_name(dev));
 }
 
 static int iommu_reconfig_notifier(struct notifier_block *nb, unsigned long action, void *node)
@@ -495,13 +500,15 @@ static struct notifier_block iommu_reconfig_nb = {
         .notifier_call = iommu_reconfig_notifier,
 };
 
-static void iommu_dev_setup_pSeriesLP(struct pci_dev *dev)
+static void pci_dma_dev_setup_pSeriesLP(struct pci_dev *dev)
 {
         struct device_node *pdn, *dn;
         struct iommu_table *tbl;
         const void *dma_window = NULL;
         struct pci_dn *pci;
 
+        DBG("pci_dma_dev_setup_pSeriesLP: %s\n", pci_name(dev));
+
         /* dev setup for LPAR is a little tricky, since the device tree might
          * contain the dma-window properties per-device and not neccesarily
          * for the bus. So we need to search upwards in the tree until we
@@ -509,9 +516,7 @@ static void iommu_dev_setup_pSeriesLP(struct pci_dev *dev)
          * already allocated.
          */
         dn = pci_device_to_OF_node(dev);
-
-        DBG("iommu_dev_setup_pSeriesLP, dev %p (%s) %s\n",
-             dev, pci_name(dev), dn->full_name);
+        DBG("  node is %s\n", dn->full_name);
 
         for (pdn = dn; pdn && PCI_DN(pdn) && !PCI_DN(pdn)->iommu_table;
              pdn = pdn->parent) {
@@ -520,16 +525,17 @@ static void iommu_dev_setup_pSeriesLP(struct pci_dev *dev)
                         break;
         }
 
+        DBG("  parent is %s\n", pdn->full_name);
+
         /* Check for parent == NULL so we don't try to setup the empty EADS
          * slots on POWER4 machines.
          */
         if (dma_window == NULL || pdn->parent == NULL) {
-                DBG("No dma window for device, linking to parent\n");
-                PCI_DN(dn)->iommu_table = PCI_DN(pdn)->iommu_table;
+                DBG("  no dma window for device, linking to parent\n");
+                dev->dev.archdata.dma_data = PCI_DN(pdn)->iommu_table;
                 return;
-        } else {
-                DBG("Found DMA window, allocating table\n");
         }
+        DBG("  found DMA window, table: %p\n", pci->iommu_table);
 
         pci = PCI_DN(pdn);
         if (!pci->iommu_table) {
@@ -542,24 +548,20 @@ static void iommu_dev_setup_pSeriesLP(struct pci_dev *dev)
                 iommu_table_setparms_lpar(pci->phb, pdn, tbl, dma_window);
 
                 pci->iommu_table = iommu_init_table(tbl, pci->phb->node);
+                DBG("  created table: %p\n", pci->iommu_table);
         }
 
-        if (pdn != dn)
-                PCI_DN(dn)->iommu_table = pci->iommu_table;
+        dev->dev.archdata.dma_data = pci->iommu_table;
 }
 
-static void iommu_bus_setup_null(struct pci_bus *b) { }
-static void iommu_dev_setup_null(struct pci_dev *d) { }
-
 /* These are called very early. */
 void iommu_init_early_pSeries(void)
 {
         if (of_chosen && get_property(of_chosen, "linux,iommu-off", NULL)) {
                 /* Direct I/O, IOMMU off */
-                ppc_md.iommu_dev_setup = iommu_dev_setup_null;
-                ppc_md.iommu_bus_setup = iommu_bus_setup_null;
-                pci_direct_iommu_init();
-
+                ppc_md.pci_dma_dev_setup = NULL;
+                ppc_md.pci_dma_bus_setup = NULL;
+                pci_dma_ops = &dma_direct_ops;
                 return;
         }
 
@@ -572,19 +574,19 @@ void iommu_init_early_pSeries(void)
                         ppc_md.tce_free  = tce_free_pSeriesLP;
                 }
                 ppc_md.tce_get   = tce_get_pSeriesLP;
-                ppc_md.iommu_bus_setup = iommu_bus_setup_pSeriesLP;
-                ppc_md.iommu_dev_setup = iommu_dev_setup_pSeriesLP;
+                ppc_md.pci_dma_bus_setup = pci_dma_bus_setup_pSeriesLP;
+                ppc_md.pci_dma_dev_setup = pci_dma_dev_setup_pSeriesLP;
         } else {
                 ppc_md.tce_build = tce_build_pSeries;
                 ppc_md.tce_free  = tce_free_pSeries;
                 ppc_md.tce_get   = tce_get_pseries;
-                ppc_md.iommu_bus_setup = iommu_bus_setup_pSeries;
-                ppc_md.iommu_dev_setup = iommu_dev_setup_pSeries;
+                ppc_md.pci_dma_bus_setup = pci_dma_bus_setup_pSeries;
+                ppc_md.pci_dma_dev_setup = pci_dma_dev_setup_pSeries;
         }
 
 
         pSeries_reconfig_notifier_register(&iommu_reconfig_nb);
 
-        pci_iommu_init();
+        pci_dma_ops = &dma_iommu_ops;
 }
 
diff --git a/arch/powerpc/platforms/pseries/lpar.c b/arch/powerpc/platforms/pseries/lpar.c
index 1820a0b0a8c6..721436db3ef0 100644
--- a/arch/powerpc/platforms/pseries/lpar.c
+++ b/arch/powerpc/platforms/pseries/lpar.c
@@ -282,7 +282,7 @@ void vpa_init(int cpu)
         }
 }
 
-long pSeries_lpar_hpte_insert(unsigned long hpte_group,
+static long pSeries_lpar_hpte_insert(unsigned long hpte_group,
                               unsigned long va, unsigned long pa,
                               unsigned long rflags, unsigned long vflags,
                               int psize)
@@ -506,7 +506,7 @@ static void pSeries_lpar_hpte_invalidate(unsigned long slot, unsigned long va,
  * Take a spinlock around flushes to avoid bouncing the hypervisor tlbie
  * lock.
  */
-void pSeries_lpar_flush_hash_range(unsigned long number, int local)
+static void pSeries_lpar_flush_hash_range(unsigned long number, int local)
 {
         int i;
         unsigned long flags = 0;
diff --git a/arch/powerpc/platforms/pseries/pci.c b/arch/powerpc/platforms/pseries/pci.c
index 410a6bcc4ca0..715db5c89908 100644
--- a/arch/powerpc/platforms/pseries/pci.c
+++ b/arch/powerpc/platforms/pseries/pci.c
@@ -29,8 +29,6 @@
 #include <asm/prom.h>
 #include <asm/ppc-pci.h>
 
-static int __devinitdata s7a_workaround = -1;
-
 #if 0
 void pcibios_name_device(struct pci_dev *dev)
 {
@@ -57,39 +55,6 @@ void pcibios_name_device(struct pci_dev *dev)
 DECLARE_PCI_FIXUP_HEADER(PCI_ANY_ID, PCI_ANY_ID, pcibios_name_device);
 #endif
 
-static void __devinit check_s7a(void)
-{
-        struct device_node *root;
-        const char *model;
-
-        s7a_workaround = 0;
-        root = of_find_node_by_path("/");
-        if (root) {
-                model = get_property(root, "model", NULL);
-                if (model && !strcmp(model, "IBM,7013-S7A"))
-                        s7a_workaround = 1;
-                of_node_put(root);
-        }
-}
-
-void __devinit pSeries_irq_bus_setup(struct pci_bus *bus)
-{
-        struct pci_dev *dev;
-
-        if (s7a_workaround < 0)
-                check_s7a();
-        list_for_each_entry(dev, &bus->devices, bus_list) {
-                pci_read_irq_line(dev);
-                if (s7a_workaround) {
-                        if (dev->irq > 16) {
-                                dev->irq -= 3;
-                                pci_write_config_byte(dev, PCI_INTERRUPT_LINE,
-                                        dev->irq);
-                        }
-                }
-        }
-}
-
 static void __init pSeries_request_regions(void)
 {
         if (!isa_io_base)
diff --git a/arch/powerpc/platforms/pseries/pci_dlpar.c b/arch/powerpc/platforms/pseries/pci_dlpar.c
index 6bfacc217085..ac56b868913a 100644
--- a/arch/powerpc/platforms/pseries/pci_dlpar.c
+++ b/arch/powerpc/platforms/pseries/pci_dlpar.c
@@ -93,8 +93,8 @@ pcibios_fixup_new_pci_devices(struct pci_bus *bus, int fix_bus)
                 if (list_empty(&dev->global_list)) {
                         int i;
 
-                        /* Need to setup IOMMU tables */
-                        ppc_md.iommu_dev_setup(dev);
+                        /* Fill device archdata and setup iommu table */
+                        pcibios_setup_new_device(dev);
 
                         if(fix_bus)
                                 pcibios_fixup_device_resources(dev, bus);
@@ -195,7 +195,7 @@ struct pci_controller * __devinit init_phb_dynamic(struct device_node *dn)
         phb = pcibios_alloc_controller(dn);
         if (!phb)
                 return NULL;
-        setup_phb(dn, phb);
+        rtas_setup_phb(phb);
         pci_process_bridge_OF_ranges(phb, dn, 0);
 
         pci_setup_phb_io_dynamic(phb, primary);
diff --git a/arch/powerpc/platforms/pseries/reconfig.c b/arch/powerpc/platforms/pseries/reconfig.c
index 1773103354be..4ad33e41b008 100644
--- a/arch/powerpc/platforms/pseries/reconfig.c
+++ b/arch/powerpc/platforms/pseries/reconfig.c
@@ -268,11 +268,10 @@ static char * parse_next_property(char *buf, char *end, char **name, int *length
 static struct property *new_property(const char *name, const int length,
                                      const unsigned char *value, struct property *last)
 {
-        struct property *new = kmalloc(sizeof(*new), GFP_KERNEL);
+        struct property *new = kzalloc(sizeof(*new), GFP_KERNEL);
 
         if (!new)
                 return NULL;
-        memset(new, 0, sizeof(*new));
 
         if (!(new->name = kmalloc(strlen(name) + 1, GFP_KERNEL)))
                 goto cleanup;
diff --git a/arch/powerpc/platforms/pseries/scanlog.c b/arch/powerpc/platforms/pseries/scanlog.c
index 77a5bb1d9c30..45368a57d7dd 100644
--- a/arch/powerpc/platforms/pseries/scanlog.c
+++ b/arch/powerpc/platforms/pseries/scanlog.c
@@ -47,7 +47,7 @@ static struct proc_dir_entry *proc_ppc64_scan_log_dump;	/* The proc file */
 static ssize_t scanlog_read(struct file *file, char __user *buf,
                             size_t count, loff_t *ppos)
 {
-        struct inode * inode = file->f_dentry->d_inode;
+        struct inode * inode = file->f_path.dentry->d_inode;
         struct proc_dir_entry *dp;
         unsigned int *data;
         int status;
diff --git a/arch/powerpc/platforms/pseries/setup.c b/arch/powerpc/platforms/pseries/setup.c
index 89a8119f988d..042ecae107ac 100644
--- a/arch/powerpc/platforms/pseries/setup.c
+++ b/arch/powerpc/platforms/pseries/setup.c
@@ -347,17 +347,6 @@ static int __init pSeries_init_panel(void)
 }
 arch_initcall(pSeries_init_panel);
 
-static void pSeries_mach_cpu_die(void)
-{
-        local_irq_disable();
-        idle_task_exit();
-        xics_teardown_cpu(0);
-        rtas_stop_self();
-        /* Should never get here... */
-        BUG();
-        for(;;);
-}
-
 static int pseries_set_dabr(unsigned long dabr)
 {
         return plpar_hcall_norets(H_SET_DABR, dabr);
@@ -433,19 +422,14 @@ static int __init pSeries_probe_hypertas(unsigned long node,
         if (of_get_flat_dt_prop(node, "ibm,hypertas-functions", NULL) != NULL)
                 powerpc_firmware_features |= FW_FEATURE_LPAR;
 
-        if (firmware_has_feature(FW_FEATURE_LPAR))
-                hpte_init_lpar();
-        else
-                hpte_init_native();
-
         return 1;
 }
 
 static int __init pSeries_probe(void)
 {
         unsigned long root = of_get_flat_dt_root();
-        char *dtype = of_get_flat_dt_prop(of_get_flat_dt_root(),
-                                          "device_type", NULL);
+        char *dtype = of_get_flat_dt_prop(root, "device_type", NULL);
+
         if (dtype == NULL)
                 return 0;
         if (strcmp(dtype, "chrp"))
@@ -463,6 +447,11 @@ static int __init pSeries_probe(void)
         /* Now try to figure out if we are running on LPAR */
         of_scan_flat_dt(pSeries_probe_hypertas, NULL);
 
+        if (firmware_has_feature(FW_FEATURE_LPAR))
+                hpte_init_lpar();
+        else
+                hpte_init_native();
+
         DBG("Machine is%s LPAR !\n",
             (powerpc_firmware_features & FW_FEATURE_LPAR) ? "" : " not");
 
@@ -553,12 +542,10 @@ define_machine(pseries) {
         .log_error              = pSeries_log_error,
         .pcibios_fixup          = pSeries_final_fixup,
         .pci_probe_mode         = pSeries_pci_probe_mode,
-        .irq_bus_setup          = pSeries_irq_bus_setup,
         .restart                = rtas_restart,
         .power_off              = rtas_power_off,
         .halt                   = rtas_halt,
         .panic                  = rtas_os_term,
-        .cpu_die                = pSeries_mach_cpu_die,
         .get_boot_time          = rtas_get_boot_time,
         .get_rtc_time           = rtas_get_rtc_time,
         .set_rtc_time           = rtas_set_rtc_time,
diff --git a/arch/powerpc/platforms/pseries/smp.c b/arch/powerpc/platforms/pseries/smp.c
index c6624b8a0e77..4408518eaebe 100644
--- a/arch/powerpc/platforms/pseries/smp.c
+++ b/arch/powerpc/platforms/pseries/smp.c
@@ -64,197 +64,6 @@ static cpumask_t of_spin_map;
 
 extern void generic_secondary_smp_init(unsigned long);
 
-#ifdef CONFIG_HOTPLUG_CPU
-
-/* Get state of physical CPU.
- * Return codes:
- *      0       - The processor is in the RTAS stopped state
- *      1       - stop-self is in progress
- *      2       - The processor is not in the RTAS stopped state
- *      -1      - Hardware Error
- *      -2      - Hardware Busy, Try again later.
- */
-static int query_cpu_stopped(unsigned int pcpu)
-{
-        int cpu_status;
-        int status, qcss_tok;
-
-        qcss_tok = rtas_token("query-cpu-stopped-state");
-        if (qcss_tok == RTAS_UNKNOWN_SERVICE)
-                return -1;
-        status = rtas_call(qcss_tok, 1, 2, &cpu_status, pcpu);
-        if (status != 0) {
-                printk(KERN_ERR
-                       "RTAS query-cpu-stopped-state failed: %i\n", status);
-                return status;
-        }
-
-        return cpu_status;
-}
-
-static int pSeries_cpu_disable(void)
-{
-        int cpu = smp_processor_id();
-
-        cpu_clear(cpu, cpu_online_map);
-        vdso_data->processorCount--;
-
-        /*fix boot_cpuid here*/
-        if (cpu == boot_cpuid)
-                boot_cpuid = any_online_cpu(cpu_online_map);
-
-        /* FIXME: abstract this to not be platform specific later on */
-        xics_migrate_irqs_away();
-        return 0;
-}
-
-static void pSeries_cpu_die(unsigned int cpu)
-{
-        int tries;
-        int cpu_status;
-        unsigned int pcpu = get_hard_smp_processor_id(cpu);
-
-        for (tries = 0; tries < 25; tries++) {
-                cpu_status = query_cpu_stopped(pcpu);
-                if (cpu_status == 0 || cpu_status == -1)
-                        break;
-                msleep(200);
-        }
-        if (cpu_status != 0) {
-                printk("Querying DEAD? cpu %i (%i) shows %i\n",
-                       cpu, pcpu, cpu_status);
-        }
-
-        /* Isolation and deallocation are definatly done by
-         * drslot_chrp_cpu.  If they were not they would be
-         * done here.  Change isolate state to Isolate and
-         * change allocation-state to Unusable.
-         */
-        paca[cpu].cpu_start = 0;
-}
-
-/*
- * Update cpu_present_map and paca(s) for a new cpu node.  The wrinkle
- * here is that a cpu device node may represent up to two logical cpus
- * in the SMT case.  We must honor the assumption in other code that
- * the logical ids for sibling SMT threads x and y are adjacent, such
- * that x^1 == y and y^1 == x.
- */
-static int pSeries_add_processor(struct device_node *np)
-{
-        unsigned int cpu;
-        cpumask_t candidate_map, tmp = CPU_MASK_NONE;
-        int err = -ENOSPC, len, nthreads, i;
-        const u32 *intserv;
-
-        intserv = get_property(np, "ibm,ppc-interrupt-server#s", &len);
-        if (!intserv)
-                return 0;
-
-        nthreads = len / sizeof(u32);
-        for (i = 0; i < nthreads; i++)
-                cpu_set(i, tmp);
-
-        lock_cpu_hotplug();
-
-        BUG_ON(!cpus_subset(cpu_present_map, cpu_possible_map));
-
-        /* Get a bitmap of unoccupied slots. */
-        cpus_xor(candidate_map, cpu_possible_map, cpu_present_map);
-        if (cpus_empty(candidate_map)) {
-                /* If we get here, it most likely means that NR_CPUS is
-                 * less than the partition's max processors setting.
-                 */
-                printk(KERN_ERR "Cannot add cpu %s; this system configuration"
-                       " supports %d logical cpus.\n", np->full_name,
-                       cpus_weight(cpu_possible_map));
-                goto out_unlock;
-        }
-
-        while (!cpus_empty(tmp))
-                if (cpus_subset(tmp, candidate_map))
-                        /* Found a range where we can insert the new cpu(s) */
-                        break;
-                else
-                        cpus_shift_left(tmp, tmp, nthreads);
-
-        if (cpus_empty(tmp)) {
-                printk(KERN_ERR "Unable to find space in cpu_present_map for"
-                       " processor %s with %d thread(s)\n", np->name,
-                       nthreads);
-                goto out_unlock;
-        }
-
-        for_each_cpu_mask(cpu, tmp) {
-                BUG_ON(cpu_isset(cpu, cpu_present_map));
-                cpu_set(cpu, cpu_present_map);
-                set_hard_smp_processor_id(cpu, *intserv++);
-        }
-        err = 0;
-out_unlock:
-        unlock_cpu_hotplug();
-        return err;
-}
-
-/*
- * Update the present map for a cpu node which is going away, and set
- * the hard id in the paca(s) to -1 to be consistent with boot time
- * convention for non-present cpus.
- */
-static void pSeries_remove_processor(struct device_node *np)
-{
-        unsigned int cpu;
-        int len, nthreads, i;
-        const u32 *intserv;
-
-        intserv = get_property(np, "ibm,ppc-interrupt-server#s", &len);
-        if (!intserv)
-                return;
-
-        nthreads = len / sizeof(u32);
-
-        lock_cpu_hotplug();
-        for (i = 0; i < nthreads; i++) {
-                for_each_present_cpu(cpu) {
-                        if (get_hard_smp_processor_id(cpu) != intserv[i])
-                                continue;
-                        BUG_ON(cpu_online(cpu));
-                        cpu_clear(cpu, cpu_present_map);
-                        set_hard_smp_processor_id(cpu, -1);
-                        break;
-                }
-                if (cpu == NR_CPUS)
-                        printk(KERN_WARNING "Could not find cpu to remove "
-                               "with physical id 0x%x\n", intserv[i]);
-        }
-        unlock_cpu_hotplug();
-}
-
-static int pSeries_smp_notifier(struct notifier_block *nb, unsigned long action, void *node)
-{
-        int err = NOTIFY_OK;
-
-        switch (action) {
-        case PSERIES_RECONFIG_ADD:
-                if (pSeries_add_processor(node))
-                        err = NOTIFY_BAD;
-                break;
-        case PSERIES_RECONFIG_REMOVE:
-                pSeries_remove_processor(node);
-                break;
-        default:
-                err = NOTIFY_DONE;
-                break;
-        }
-        return err;
-}
-
-static struct notifier_block pSeries_smp_nb = {
-        .notifier_call = pSeries_smp_notifier,
-};
-
-#endif /* CONFIG_HOTPLUG_CPU */
-
 /**
  * smp_startup_cpu() - start the given cpu
  *
@@ -422,15 +231,6 @@ static void __init smp_init_pseries(void)
 
         DBG(" -> smp_init_pSeries()\n");
 
-#ifdef CONFIG_HOTPLUG_CPU
-        smp_ops->cpu_disable = pSeries_cpu_disable;
-        smp_ops->cpu_die = pSeries_cpu_die;
-
-        /* Processors can be added/removed only on LPAR */
-        if (firmware_has_feature(FW_FEATURE_LPAR))
-                pSeries_reconfig_notifier_register(&pSeries_smp_nb);
-#endif
-
         /* Mark threads which are still spinning in hold loops. */
         if (cpu_has_feature(CPU_FTR_SMT)) {
                 for_each_present_cpu(i) { 
diff --git a/arch/powerpc/platforms/pseries/xics.c b/arch/powerpc/platforms/pseries/xics.c
index d071abe78ab1..81d172d65038 100644
--- a/arch/powerpc/platforms/pseries/xics.c
+++ b/arch/powerpc/platforms/pseries/xics.c
@@ -224,7 +224,6 @@ static void xics_unmask_irq(unsigned int virq)
 static void xics_mask_real_irq(unsigned int irq)
 {
         int call_status;
-        unsigned int server;
 
         if (irq == XICS_IPI)
                 return;
@@ -236,9 +235,9 @@ static void xics_mask_real_irq(unsigned int irq)
                 return;
         }
 
-        server = get_irq_server(irq);
         /* Have to set XIVE to 0xff to be able to remove a slot */
-        call_status = rtas_call(ibm_set_xive, 3, 1, NULL, irq, server, 0xff);
+        call_status = rtas_call(ibm_set_xive, 3, 1, NULL, irq,
+                                default_server, 0xff);
         if (call_status != 0) {
                 printk(KERN_ERR "xics_disable_irq: irq=%u: ibm_set_xive(0xff)"
                        " returned %d\n", irq, call_status);
@@ -656,13 +655,38 @@ static void __init xics_setup_8259_cascade(void)
         set_irq_chained_handler(cascade, pseries_8259_cascade);
 }
 
+static struct device_node *cpuid_to_of_node(int cpu)
+{
+        struct device_node *np;
+        u32 hcpuid = get_hard_smp_processor_id(cpu);
+
+        for_each_node_by_type(np, "cpu") {
+                int i, len;
+                const u32 *intserv;
+
+                intserv = get_property(np, "ibm,ppc-interrupt-server#s", &len);
+
+                if (!intserv)
+                        intserv = get_property(np, "reg", &len);
+
+                i = len / sizeof(u32);
+
+                while (i--)
+                        if (intserv[i] == hcpuid)
+                                return np;
+        }
+
+        return NULL;
+}
+
 void __init xics_init_IRQ(void)
 {
-        int i;
+        int i, j;
         struct device_node *np;
         u32 ilen, indx = 0;
-        const u32 *ireg;
+        const u32 *ireg, *isize;
         int found = 0;
+        u32 hcpuid;
 
         ppc64_boot_msg(0x20, "XICS Init");
 
@@ -683,26 +707,31 @@ void __init xics_init_IRQ(void)
         xics_init_host();
 
         /* Find the server numbers for the boot cpu. */
-        for (np = of_find_node_by_type(NULL, "cpu");
-             np;
-             np = of_find_node_by_type(np, "cpu")) {
-                ireg = get_property(np, "reg", &ilen);
-                if (ireg && ireg[0] == get_hard_smp_processor_id(boot_cpuid)) {
-                        ireg = get_property(np,
-                                        "ibm,ppc-interrupt-gserver#s", &ilen);
-                        i = ilen / sizeof(int);
-                        if (ireg && i > 0) {
-                                default_server = ireg[0];
-                                /* take last element */
-                                default_distrib_server = ireg[i-1];
-                        }
-                        ireg = get_property(np,
+        np = cpuid_to_of_node(boot_cpuid);
+        BUG_ON(!np);
+        ireg = get_property(np, "ibm,ppc-interrupt-gserver#s", &ilen);
+        if (!ireg)
+                goto skip_gserver_check;
+        i = ilen / sizeof(int);
+        hcpuid = get_hard_smp_processor_id(boot_cpuid);
+
+        /* Global interrupt distribution server is specified in the last
+         * entry of "ibm,ppc-interrupt-gserver#s" property. Get the last
+         * entry fom this property for current boot cpu id and use it as
+         * default distribution server
+         */
+        for (j = 0; j < i; j += 2) {
+                if (ireg[j] == hcpuid) {
+                        default_server = hcpuid;
+                        default_distrib_server = ireg[j+1];
+
+                        isize = get_property(np,
                                         "ibm,interrupt-server#-size", NULL);
-                        if (ireg)
-                                interrupt_server_size = *ireg;
-                        break;
+                        if (isize)
+                                interrupt_server_size = *isize;
                 }
         }
+skip_gserver_check:
         of_node_put(np);
 
         if (firmware_has_feature(FW_FEATURE_LPAR))