Merge commit 'v2.6.33-rc5' into secretlab/test-devicetree

79 files changed, 4168 insertions, 898 deletions

diff --git a/arch/powerpc/platforms/512x/mpc5121_ads_cpld.c b/arch/powerpc/platforms/512x/mpc5121_ads_cpld.c
index a6ce80566625..da9b20a63769 100644
--- a/arch/powerpc/platforms/512x/mpc5121_ads_cpld.c
+++ b/arch/powerpc/platforms/512x/mpc5121_ads_cpld.c
@@ -79,7 +79,7 @@ cpld_unmask_irq(unsigned int irq)
 }
 
 static struct irq_chip cpld_pic = {
-        .typename = " CPLD PIC ",
+        .name = " CPLD PIC ",
         .mask = cpld_mask_irq,
         .ack = cpld_mask_irq,
         .unmask = cpld_unmask_irq,
@@ -132,7 +132,7 @@ static int
 cpld_pic_host_map(struct irq_host *h, unsigned int virq,
                              irq_hw_number_t hw)
 {
-        get_irq_desc(virq)->status |= IRQ_LEVEL;
+        irq_to_desc(virq)->status |= IRQ_LEVEL;
         set_irq_chip_and_handler(virq, &cpld_pic, handle_level_irq);
         return 0;
 }
diff --git a/arch/powerpc/platforms/52xx/Kconfig b/arch/powerpc/platforms/52xx/Kconfig
index 8b8e9560a315..47ea1be1481b 100644
--- a/arch/powerpc/platforms/52xx/Kconfig
+++ b/arch/powerpc/platforms/52xx/Kconfig
@@ -62,3 +62,8 @@ config PPC_MPC5200_GPIO
         select GENERIC_GPIO
         help
           Enable gpiolib support for mpc5200 based boards
+
+config PPC_MPC5200_LPBFIFO
+        tristate "MPC5200 LocalPlus bus FIFO driver"
+        depends on PPC_MPC52xx
+        select PPC_BESTCOMM_GEN_BD
diff --git a/arch/powerpc/platforms/52xx/Makefile b/arch/powerpc/platforms/52xx/Makefile
index bfd4f52cf3dd..2bc8cd0c5cfc 100644
--- a/arch/powerpc/platforms/52xx/Makefile
+++ b/arch/powerpc/platforms/52xx/Makefile
@@ -15,3 +15,4 @@ ifeq ($(CONFIG_PPC_LITE5200),y)
 endif
 
 obj-$(CONFIG_PPC_MPC5200_GPIO)  += mpc52xx_gpio.o
+obj-$(CONFIG_PPC_MPC5200_LPBFIFO)       += mpc52xx_lpbfifo.o
diff --git a/arch/powerpc/platforms/52xx/efika.c b/arch/powerpc/platforms/52xx/efika.c
index bcc69e1f77c1..45c0cb9b67e6 100644
--- a/arch/powerpc/platforms/52xx/efika.c
+++ b/arch/powerpc/platforms/52xx/efika.c
@@ -10,7 +10,7 @@
  */
 
 #include <linux/init.h>
-#include <linux/utsrelease.h>
+#include <generated/utsrelease.h>
 #include <linux/pci.h>
 #include <linux/of.h>
 #include <asm/prom.h>
diff --git a/arch/powerpc/platforms/52xx/media5200.c b/arch/powerpc/platforms/52xx/media5200.c
index 68e4f1696d14..0bac3a3dbecf 100644
--- a/arch/powerpc/platforms/52xx/media5200.c
+++ b/arch/powerpc/platforms/52xx/media5200.c
@@ -74,7 +74,7 @@ static void media5200_irq_mask(unsigned int virq)
 }
 
 static struct irq_chip media5200_irq_chip = {
-        .typename = "Media5200 FPGA",
+        .name = "Media5200 FPGA",
         .unmask = media5200_irq_unmask,
         .mask = media5200_irq_mask,
         .mask_ack = media5200_irq_mask,
@@ -86,9 +86,9 @@ void media5200_irq_cascade(unsigned int virq, struct irq_desc *desc)
         u32 status, enable;
 
         /* Mask off the cascaded IRQ */
-        spin_lock(&desc->lock);
+        raw_spin_lock(&desc->lock);
         desc->chip->mask(virq);
-        spin_unlock(&desc->lock);
+        raw_spin_unlock(&desc->lock);
 
         /* Ask the FPGA for IRQ status.  If 'val' is 0, then no irqs
          * are pending.  'ffs()' is 1 based */
@@ -104,17 +104,17 @@ void media5200_irq_cascade(unsigned int virq, struct irq_desc *desc)
         }
 
         /* Processing done; can reenable the cascade now */
-        spin_lock(&desc->lock);
+        raw_spin_lock(&desc->lock);
         desc->chip->ack(virq);
         if (!(desc->status & IRQ_DISABLED))
                 desc->chip->unmask(virq);
-        spin_unlock(&desc->lock);
+        raw_spin_unlock(&desc->lock);
 }
 
 static int media5200_irq_map(struct irq_host *h, unsigned int virq,
                              irq_hw_number_t hw)
 {
-        struct irq_desc *desc = get_irq_desc(virq);
+        struct irq_desc *desc = irq_to_desc(virq);
 
         pr_debug("%s: h=%p, virq=%i, hwirq=%i\n", __func__, h, virq, (int)hw);
         set_irq_chip_data(virq, &media5200_irq);
@@ -127,7 +127,7 @@ static int media5200_irq_map(struct irq_host *h, unsigned int virq,
 }
 
 static int media5200_irq_xlate(struct irq_host *h, struct device_node *ct,
-                                 u32 *intspec, unsigned int intsize,
+                                 const u32 *intspec, unsigned int intsize,
                                  irq_hw_number_t *out_hwirq,
                                  unsigned int *out_flags)
 {
diff --git a/arch/powerpc/platforms/52xx/mpc52xx_gpt.c b/arch/powerpc/platforms/52xx/mpc52xx_gpt.c
index bfbcd418e690..6f8ebe1085b3 100644
--- a/arch/powerpc/platforms/52xx/mpc52xx_gpt.c
+++ b/arch/powerpc/platforms/52xx/mpc52xx_gpt.c
@@ -16,8 +16,14 @@
  * output signals or measure input signals.
  *
  * This driver supports the GPIO and IRQ controller functions of the GPT
- * device.  Timer functions are not yet supported, nor is the watchdog
- * timer.
+ * device.  Timer functions are not yet supported.
+ *
+ * The timer gpt0 can be used as watchdog (wdt).  If the wdt mode is used,
+ * this prevents the use of any gpt0 gpt function (i.e. they will fail with
+ * -EBUSY).  Thus, the safety wdt function always has precedence over the gpt
+ * function.  If the kernel has been compiled with CONFIG_WATCHDOG_NOWAYOUT,
+ * this means that gpt0 is locked in wdt mode until the next reboot - this
+ * may be a requirement in safety applications.
  *
  * To use the GPIO function, the following two properties must be added
  * to the device tree node for the gpt device (typically in the .dts file
@@ -46,17 +52,24 @@
  * the output mode.  This driver does not change the output mode setting.
  */
 
+#include <linux/device.h>
 #include <linux/irq.h>
 #include <linux/interrupt.h>
 #include <linux/io.h>
+#include <linux/list.h>
+#include <linux/mutex.h>
 #include <linux/of.h>
 #include <linux/of_platform.h>
 #include <linux/of_gpio.h>
 #include <linux/kernel.h>
+#include <linux/watchdog.h>
+#include <linux/miscdevice.h>
+#include <linux/uaccess.h>
+#include <asm/div64.h>
 #include <asm/mpc52xx.h>
 
 MODULE_DESCRIPTION("Freescale MPC52xx gpt driver");
-MODULE_AUTHOR("Sascha Hauer, Grant Likely");
+MODULE_AUTHOR("Sascha Hauer, Grant Likely, Albrecht Dreß");
 MODULE_LICENSE("GPL");
 
 /**
@@ -66,18 +79,27 @@ MODULE_LICENSE("GPL");
  * @lock: spinlock to coordinate between different functions.
  * @of_gc: of_gpio_chip instance structure; used when GPIO is enabled
  * @irqhost: Pointer to irq_host instance; used when IRQ mode is supported
+ * @wdt_mode: only relevant for gpt0: bit 0 (MPC52xx_GPT_CAN_WDT) indicates
+ *   if the gpt may be used as wdt, bit 1 (MPC52xx_GPT_IS_WDT) indicates
+ *   if the timer is actively used as wdt which blocks gpt functions
  */
 struct mpc52xx_gpt_priv {
+        struct list_head list;          /* List of all GPT devices */
         struct device *dev;
         struct mpc52xx_gpt __iomem *regs;
         spinlock_t lock;
         struct irq_host *irqhost;
+        u32 ipb_freq;
+        u8 wdt_mode;
 
 #if defined(CONFIG_GPIOLIB)
         struct of_gpio_chip of_gc;
 #endif
 };
 
+LIST_HEAD(mpc52xx_gpt_list);
+DEFINE_MUTEX(mpc52xx_gpt_list_mutex);
+
 #define MPC52xx_GPT_MODE_MS_MASK        (0x07)
 #define MPC52xx_GPT_MODE_MS_IC          (0x01)
 #define MPC52xx_GPT_MODE_MS_OC          (0x02)
@@ -88,15 +110,25 @@ struct mpc52xx_gpt_priv {
 #define MPC52xx_GPT_MODE_GPIO_OUT_LOW   (0x20)
 #define MPC52xx_GPT_MODE_GPIO_OUT_HIGH  (0x30)
 
+#define MPC52xx_GPT_MODE_COUNTER_ENABLE (0x1000)
+#define MPC52xx_GPT_MODE_CONTINUOUS     (0x0400)
+#define MPC52xx_GPT_MODE_OPEN_DRAIN     (0x0200)
 #define MPC52xx_GPT_MODE_IRQ_EN         (0x0100)
+#define MPC52xx_GPT_MODE_WDT_EN         (0x8000)
 
 #define MPC52xx_GPT_MODE_ICT_MASK       (0x030000)
 #define MPC52xx_GPT_MODE_ICT_RISING     (0x010000)
 #define MPC52xx_GPT_MODE_ICT_FALLING    (0x020000)
 #define MPC52xx_GPT_MODE_ICT_TOGGLE     (0x030000)
 
+#define MPC52xx_GPT_MODE_WDT_PING       (0xa5)
+
 #define MPC52xx_GPT_STATUS_IRQMASK      (0x000f)
 
+#define MPC52xx_GPT_CAN_WDT             (1 << 0)
+#define MPC52xx_GPT_IS_WDT              (1 << 1)
+
+
 /* ---------------------------------------------------------------------
  * Cascaded interrupt controller hooks
  */
@@ -149,7 +181,7 @@ static int mpc52xx_gpt_irq_set_type(unsigned int virq, unsigned int flow_type)
 }
 
 static struct irq_chip mpc52xx_gpt_irq_chip = {
-        .typename = "MPC52xx GPT",
+        .name = "MPC52xx GPT",
         .unmask = mpc52xx_gpt_irq_unmask,
         .mask = mpc52xx_gpt_irq_mask,
         .ack = mpc52xx_gpt_irq_ack,
@@ -182,7 +214,7 @@ static int mpc52xx_gpt_irq_map(struct irq_host *h, unsigned int virq,
 }
 
 static int mpc52xx_gpt_irq_xlate(struct irq_host *h, struct device_node *ct,
-                                 u32 *intspec, unsigned int intsize,
+                                 const u32 *intspec, unsigned int intsize,
                                  irq_hw_number_t *out_hwirq,
                                  unsigned int *out_flags)
 {
@@ -190,7 +222,7 @@ static int mpc52xx_gpt_irq_xlate(struct irq_host *h, struct device_node *ct,
 
         dev_dbg(gpt->dev, "%s: flags=%i\n", __func__, intspec[0]);
 
-        if ((intsize < 1) || (intspec[0] < 1) || (intspec[0] > 3)) {
+        if ((intsize < 1) || (intspec[0] > 3)) {
                 dev_err(gpt->dev, "bad irq specifier in %s\n", ct->full_name);
                 return -EINVAL;
         }
@@ -211,13 +243,11 @@ mpc52xx_gpt_irq_setup(struct mpc52xx_gpt_priv *gpt, struct device_node *node)
 {
         int cascade_virq;
         unsigned long flags;
-
-        /* Only setup cascaded IRQ if device tree claims the GPT is
-         * an interrupt controller */
-        if (!of_find_property(node, "interrupt-controller", NULL))
-                return;
+        u32 mode;
 
         cascade_virq = irq_of_parse_and_map(node, 0);
+        if (!cascade_virq)
+                return;
 
         gpt->irqhost = irq_alloc_host(node, IRQ_HOST_MAP_LINEAR, 1,
                                       &mpc52xx_gpt_irq_ops, -1);
@@ -227,14 +257,16 @@ mpc52xx_gpt_irq_setup(struct mpc52xx_gpt_priv *gpt, struct device_node *node)
         }
 
         gpt->irqhost->host_data = gpt;
-
         set_irq_data(cascade_virq, gpt);
         set_irq_chained_handler(cascade_virq, mpc52xx_gpt_irq_cascade);
 
-        /* Set to Input Capture mode */
+        /* If the GPT is currently disabled, then change it to be in Input
+         * Capture mode.  If the mode is non-zero, then the pin could be
+         * already in use for something. */
         spin_lock_irqsave(&gpt->lock, flags);
-        clrsetbits_be32(&gpt->regs->mode, MPC52xx_GPT_MODE_MS_MASK,
-                        MPC52xx_GPT_MODE_MS_IC);
+        mode = in_be32(&gpt->regs->mode);
+        if ((mode & MPC52xx_GPT_MODE_MS_MASK) == 0)
+                out_be32(&gpt->regs->mode, mode | MPC52xx_GPT_MODE_MS_IC);
         spin_unlock_irqrestore(&gpt->lock, flags);
 
         dev_dbg(gpt->dev, "%s() complete. virq=%i\n", __func__, cascade_virq);
@@ -335,6 +367,354 @@ static void
 mpc52xx_gpt_gpio_setup(struct mpc52xx_gpt_priv *p, struct device_node *np) { }
 #endif /* defined(CONFIG_GPIOLIB) */
 
+/***********************************************************************
+ * Timer API
+ */
+
+/**
+ * mpc52xx_gpt_from_irq - Return the GPT device associated with an IRQ number
+ * @irq: irq of timer.
+ */
+struct mpc52xx_gpt_priv *mpc52xx_gpt_from_irq(int irq)
+{
+        struct mpc52xx_gpt_priv *gpt;
+        struct list_head *pos;
+
+        /* Iterate over the list of timers looking for a matching device */
+        mutex_lock(&mpc52xx_gpt_list_mutex);
+        list_for_each(pos, &mpc52xx_gpt_list) {
+                gpt = container_of(pos, struct mpc52xx_gpt_priv, list);
+                if (gpt->irqhost && irq == irq_linear_revmap(gpt->irqhost, 0)) {
+                        mutex_unlock(&mpc52xx_gpt_list_mutex);
+                        return gpt;
+                }
+        }
+        mutex_unlock(&mpc52xx_gpt_list_mutex);
+
+        return NULL;
+}
+EXPORT_SYMBOL(mpc52xx_gpt_from_irq);
+
+static int mpc52xx_gpt_do_start(struct mpc52xx_gpt_priv *gpt, u64 period,
+                                int continuous, int as_wdt)
+{
+        u32 clear, set;
+        u64 clocks;
+        u32 prescale;
+        unsigned long flags;
+
+        clear = MPC52xx_GPT_MODE_MS_MASK | MPC52xx_GPT_MODE_CONTINUOUS;
+        set = MPC52xx_GPT_MODE_MS_GPIO | MPC52xx_GPT_MODE_COUNTER_ENABLE;
+        if (as_wdt) {
+                clear |= MPC52xx_GPT_MODE_IRQ_EN;
+                set |= MPC52xx_GPT_MODE_WDT_EN;
+        } else if (continuous)
+                set |= MPC52xx_GPT_MODE_CONTINUOUS;
+
+        /* Determine the number of clocks in the requested period.  64 bit
+         * arithmatic is done here to preserve the precision until the value
+         * is scaled back down into the u32 range.  Period is in 'ns', bus
+         * frequency is in Hz. */
+        clocks = period * (u64)gpt->ipb_freq;
+        do_div(clocks, 1000000000); /* Scale it down to ns range */
+
+        /* This device cannot handle a clock count greater than 32 bits */
+        if (clocks > 0xffffffff)
+                return -EINVAL;
+
+        /* Calculate the prescaler and count values from the clocks value.
+         * 'clocks' is the number of clock ticks in the period.  The timer
+         * has 16 bit precision and a 16 bit prescaler.  Prescaler is
+         * calculated by integer dividing the clocks by 0x10000 (shifting
+         * down 16 bits) to obtain the smallest possible divisor for clocks
+         * to get a 16 bit count value.
+         *
+         * Note: the prescale register is '1' based, not '0' based.  ie. a
+         * value of '1' means divide the clock by one.  0xffff divides the
+         * clock by 0xffff.  '0x0000' does not divide by zero, but wraps
+         * around and divides by 0x10000.  That is why prescale must be
+         * a u32 variable, not a u16, for this calculation. */
+        prescale = (clocks >> 16) + 1;
+        do_div(clocks, prescale);
+        if (clocks > 0xffff) {
+                pr_err("calculation error; prescale:%x clocks:%llx\n",
+                       prescale, clocks);
+                return -EINVAL;
+        }
+
+        /* Set and enable the timer, reject an attempt to use a wdt as gpt */
+        spin_lock_irqsave(&gpt->lock, flags);
+        if (as_wdt)
+                gpt->wdt_mode |= MPC52xx_GPT_IS_WDT;
+        else if ((gpt->wdt_mode & MPC52xx_GPT_IS_WDT) != 0) {
+                spin_unlock_irqrestore(&gpt->lock, flags);
+                return -EBUSY;
+        }
+        out_be32(&gpt->regs->count, prescale << 16 | clocks);
+        clrsetbits_be32(&gpt->regs->mode, clear, set);
+        spin_unlock_irqrestore(&gpt->lock, flags);
+
+        return 0;
+}
+
+/**
+ * mpc52xx_gpt_start_timer - Set and enable the GPT timer
+ * @gpt: Pointer to gpt private data structure
+ * @period: period of timer in ns; max. ~130s @ 33MHz IPB clock
+ * @continuous: set to 1 to make timer continuous free running
+ *
+ * An interrupt will be generated every time the timer fires
+ */
+int mpc52xx_gpt_start_timer(struct mpc52xx_gpt_priv *gpt, u64 period,
+                            int continuous)
+{
+        return mpc52xx_gpt_do_start(gpt, period, continuous, 0);
+}
+EXPORT_SYMBOL(mpc52xx_gpt_start_timer);
+
+/**
+ * mpc52xx_gpt_stop_timer - Stop a gpt
+ * @gpt: Pointer to gpt private data structure
+ *
+ * Returns an error if attempting to stop a wdt
+ */
+int mpc52xx_gpt_stop_timer(struct mpc52xx_gpt_priv *gpt)
+{
+        unsigned long flags;
+
+        /* reject the operation if the timer is used as watchdog (gpt 0 only) */
+        spin_lock_irqsave(&gpt->lock, flags);
+        if ((gpt->wdt_mode & MPC52xx_GPT_IS_WDT) != 0) {
+                spin_unlock_irqrestore(&gpt->lock, flags);
+                return -EBUSY;
+        }
+
+        clrbits32(&gpt->regs->mode, MPC52xx_GPT_MODE_COUNTER_ENABLE);
+        spin_unlock_irqrestore(&gpt->lock, flags);
+        return 0;
+}
+EXPORT_SYMBOL(mpc52xx_gpt_stop_timer);
+
+/**
+ * mpc52xx_gpt_timer_period - Read the timer period
+ * @gpt: Pointer to gpt private data structure
+ *
+ * Returns the timer period in ns
+ */
+u64 mpc52xx_gpt_timer_period(struct mpc52xx_gpt_priv *gpt)
+{
+        u64 period;
+        u64 prescale;
+        unsigned long flags;
+
+        spin_lock_irqsave(&gpt->lock, flags);
+        period = in_be32(&gpt->regs->count);
+        spin_unlock_irqrestore(&gpt->lock, flags);
+
+        prescale = period >> 16;
+        period &= 0xffff;
+        if (prescale == 0)
+                prescale = 0x10000;
+        period = period * prescale * 1000000000ULL;
+        do_div(period, (u64)gpt->ipb_freq);
+        return period;
+}
+EXPORT_SYMBOL(mpc52xx_gpt_timer_period);
+
+#if defined(CONFIG_MPC5200_WDT)
+/***********************************************************************
+ * Watchdog API for gpt0
+ */
+
+#define WDT_IDENTITY        "mpc52xx watchdog on GPT0"
+
+/* wdt_is_active stores wether or not the /dev/watchdog device is opened */
+static unsigned long wdt_is_active;
+
+/* wdt-capable gpt */
+static struct mpc52xx_gpt_priv *mpc52xx_gpt_wdt;
+
+/* low-level wdt functions */
+static inline void mpc52xx_gpt_wdt_ping(struct mpc52xx_gpt_priv *gpt_wdt)
+{
+        unsigned long flags;
+
+        spin_lock_irqsave(&gpt_wdt->lock, flags);
+        out_8((u8 *) &gpt_wdt->regs->mode, MPC52xx_GPT_MODE_WDT_PING);
+        spin_unlock_irqrestore(&gpt_wdt->lock, flags);
+}
+
+/* wdt misc device api */
+static ssize_t mpc52xx_wdt_write(struct file *file, const char __user *data,
+                                 size_t len, loff_t *ppos)
+{
+        struct mpc52xx_gpt_priv *gpt_wdt = file->private_data;
+        mpc52xx_gpt_wdt_ping(gpt_wdt);
+        return 0;
+}
+
+static struct watchdog_info mpc5200_wdt_info = {
+        .options        = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING,
+        .identity       = WDT_IDENTITY,
+};
+
+static long mpc52xx_wdt_ioctl(struct file *file, unsigned int cmd,
+                              unsigned long arg)
+{
+        struct mpc52xx_gpt_priv *gpt_wdt = file->private_data;
+        int __user *data = (int __user *)arg;
+        int timeout;
+        u64 real_timeout;
+        int ret = 0;
+
+        switch (cmd) {
+        case WDIOC_GETSUPPORT:
+                ret = copy_to_user(data, &mpc5200_wdt_info,
+                                   sizeof(mpc5200_wdt_info));
+                if (ret)
+                        ret = -EFAULT;
+                break;
+
+        case WDIOC_GETSTATUS:
+        case WDIOC_GETBOOTSTATUS:
+                ret = put_user(0, data);
+                break;
+
+        case WDIOC_KEEPALIVE:
+                mpc52xx_gpt_wdt_ping(gpt_wdt);
+                break;
+
+        case WDIOC_SETTIMEOUT:
+                ret = get_user(timeout, data);
+                if (ret)
+                        break;
+                real_timeout = (u64) timeout * 1000000000ULL;
+                ret = mpc52xx_gpt_do_start(gpt_wdt, real_timeout, 0, 1);
+                if (ret)
+                        break;
+                /* fall through and return the timeout */
+
+        case WDIOC_GETTIMEOUT:
+                /* we need to round here as to avoid e.g. the following
+                 * situation:
+                 * - timeout requested is 1 second;
+                 * - real timeout @33MHz is 999997090ns
+                 * - the int divide by 10^9 will return 0.
+                 */
+                real_timeout =
+                        mpc52xx_gpt_timer_period(gpt_wdt) + 500000000ULL;
+                do_div(real_timeout, 1000000000ULL);
+                timeout = (int) real_timeout;
+                ret = put_user(timeout, data);
+                break;
+
+        default:
+                ret = -ENOTTY;
+        }
+        return ret;
+}
+
+static int mpc52xx_wdt_open(struct inode *inode, struct file *file)
+{
+        int ret;
+
+        /* sanity check */
+        if (!mpc52xx_gpt_wdt)
+                return -ENODEV;
+
+        /* /dev/watchdog can only be opened once */
+        if (test_and_set_bit(0, &wdt_is_active))
+                return -EBUSY;
+
+        /* Set and activate the watchdog with 30 seconds timeout */
+        ret = mpc52xx_gpt_do_start(mpc52xx_gpt_wdt, 30ULL * 1000000000ULL,
+                                   0, 1);
+        if (ret) {
+                clear_bit(0, &wdt_is_active);
+                return ret;
+        }
+
+        file->private_data = mpc52xx_gpt_wdt;
+        return nonseekable_open(inode, file);
+}
+
+static int mpc52xx_wdt_release(struct inode *inode, struct file *file)
+{
+        /* note: releasing the wdt in NOWAYOUT-mode does not stop it */
+#if !defined(CONFIG_WATCHDOG_NOWAYOUT)
+        struct mpc52xx_gpt_priv *gpt_wdt = file->private_data;
+        unsigned long flags;
+
+        spin_lock_irqsave(&gpt_wdt->lock, flags);
+        clrbits32(&gpt_wdt->regs->mode,
+                  MPC52xx_GPT_MODE_COUNTER_ENABLE | MPC52xx_GPT_MODE_WDT_EN);
+        gpt_wdt->wdt_mode &= ~MPC52xx_GPT_IS_WDT;
+        spin_unlock_irqrestore(&gpt_wdt->lock, flags);
+#endif
+        clear_bit(0, &wdt_is_active);
+        return 0;
+}
+
+
+static const struct file_operations mpc52xx_wdt_fops = {
+        .owner          = THIS_MODULE,
+        .llseek         = no_llseek,
+        .write          = mpc52xx_wdt_write,
+        .unlocked_ioctl = mpc52xx_wdt_ioctl,
+        .open           = mpc52xx_wdt_open,
+        .release        = mpc52xx_wdt_release,
+};
+
+static struct miscdevice mpc52xx_wdt_miscdev = {
+        .minor          = WATCHDOG_MINOR,
+        .name           = "watchdog",
+        .fops           = &mpc52xx_wdt_fops,
+};
+
+static int __devinit mpc52xx_gpt_wdt_init(void)
+{
+        int err;
+
+        /* try to register the watchdog misc device */
+        err = misc_register(&mpc52xx_wdt_miscdev);
+        if (err)
+                pr_err("%s: cannot register watchdog device\n", WDT_IDENTITY);
+        else
+                pr_info("%s: watchdog device registered\n", WDT_IDENTITY);
+        return err;
+}
+
+static int mpc52xx_gpt_wdt_setup(struct mpc52xx_gpt_priv *gpt,
+                                 const u32 *period)
+{
+        u64 real_timeout;
+
+        /* remember the gpt for the wdt operation */
+        mpc52xx_gpt_wdt = gpt;
+
+        /* configure the wdt if the device tree contained a timeout */
+        if (!period || *period == 0)
+                return 0;
+
+        real_timeout = (u64) *period * 1000000000ULL;
+        if (mpc52xx_gpt_do_start(gpt, real_timeout, 0, 1))
+                dev_warn(gpt->dev, "starting as wdt failed\n");
+        else
+                dev_info(gpt->dev, "watchdog set to %us timeout\n", *period);
+        return 0;
+}
+
+#else
+
+static int __devinit mpc52xx_gpt_wdt_init(void)
+{
+        return 0;
+}
+
+#define mpc52xx_gpt_wdt_setup(x, y)             (0)
+
+#endif  /*  CONFIG_MPC5200_WDT  */
+
 /* ---------------------------------------------------------------------
  * of_platform bus binding code
  */
@@ -349,6 +729,7 @@ static int __devinit mpc52xx_gpt_probe(struct of_device *ofdev,
 
         spin_lock_init(&gpt->lock);
         gpt->dev = &ofdev->dev;
+        gpt->ipb_freq = mpc5xxx_get_bus_frequency(ofdev->node);
         gpt->regs = of_iomap(ofdev->node, 0);
         if (!gpt->regs) {
                 kfree(gpt);
@@ -360,6 +741,26 @@ static int __devinit mpc52xx_gpt_probe(struct of_device *ofdev,
         mpc52xx_gpt_gpio_setup(gpt, ofdev->node);
         mpc52xx_gpt_irq_setup(gpt, ofdev->node);
 
+        mutex_lock(&mpc52xx_gpt_list_mutex);
+        list_add(&gpt->list, &mpc52xx_gpt_list);
+        mutex_unlock(&mpc52xx_gpt_list_mutex);
+
+        /* check if this device could be a watchdog */
+        if (of_get_property(ofdev->node, "fsl,has-wdt", NULL) ||
+            of_get_property(ofdev->node, "has-wdt", NULL)) {
+                const u32 *on_boot_wdt;
+
+                gpt->wdt_mode = MPC52xx_GPT_CAN_WDT;
+                on_boot_wdt = of_get_property(ofdev->node, "fsl,wdt-on-boot",
+                                              NULL);
+                if (on_boot_wdt) {
+                        dev_info(gpt->dev, "used as watchdog\n");
+                        gpt->wdt_mode |= MPC52xx_GPT_IS_WDT;
+                } else
+                        dev_info(gpt->dev, "can function as watchdog\n");
+                mpc52xx_gpt_wdt_setup(gpt, on_boot_wdt);
+        }
+
         return 0;
 }
 
@@ -394,3 +795,4 @@ static int __init mpc52xx_gpt_init(void)
 
 /* Make sure GPIOs and IRQs get set up before anyone tries to use them */
 subsys_initcall(mpc52xx_gpt_init);
+device_initcall(mpc52xx_gpt_wdt_init);
diff --git a/arch/powerpc/platforms/52xx/mpc52xx_lpbfifo.c b/arch/powerpc/platforms/52xx/mpc52xx_lpbfifo.c
new file mode 100644
index 000000000000..929d017535a3
--- /dev/null
+++ b/arch/powerpc/platforms/52xx/mpc52xx_lpbfifo.c
@@ -0,0 +1,560 @@
+/*
+ * LocalPlus Bus FIFO driver for the Freescale MPC52xx.
+ *
+ * Copyright (C) 2009 Secret Lab Technologies Ltd.
+ *
+ * This file is released under the GPLv2
+ *
+ * Todo:
+ * - Add support for multiple requests to be queued.
+ */
+
+#include <linux/interrupt.h>
+#include <linux/kernel.h>
+#include <linux/of.h>
+#include <linux/of_platform.h>
+#include <linux/spinlock.h>
+#include <asm/io.h>
+#include <asm/prom.h>
+#include <asm/mpc52xx.h>
+#include <asm/time.h>
+
+#include <sysdev/bestcomm/bestcomm.h>
+#include <sysdev/bestcomm/bestcomm_priv.h>
+#include <sysdev/bestcomm/gen_bd.h>
+
+MODULE_AUTHOR("Grant Likely <grant.likely@secretlab.ca>");
+MODULE_DESCRIPTION("MPC5200 LocalPlus FIFO device driver");
+MODULE_LICENSE("GPL");
+
+#define LPBFIFO_REG_PACKET_SIZE         (0x00)
+#define LPBFIFO_REG_START_ADDRESS       (0x04)
+#define LPBFIFO_REG_CONTROL             (0x08)
+#define LPBFIFO_REG_ENABLE              (0x0C)
+#define LPBFIFO_REG_BYTES_DONE_STATUS   (0x14)
+#define LPBFIFO_REG_FIFO_DATA           (0x40)
+#define LPBFIFO_REG_FIFO_STATUS         (0x44)
+#define LPBFIFO_REG_FIFO_CONTROL        (0x48)
+#define LPBFIFO_REG_FIFO_ALARM          (0x4C)
+
+struct mpc52xx_lpbfifo {
+        struct device *dev;
+        phys_addr_t regs_phys;
+        void __iomem *regs;
+        int irq;
+        spinlock_t lock;
+
+        struct bcom_task *bcom_tx_task;
+        struct bcom_task *bcom_rx_task;
+        struct bcom_task *bcom_cur_task;
+
+        /* Current state data */
+        struct mpc52xx_lpbfifo_request *req;
+        int dma_irqs_enabled;
+};
+
+/* The MPC5200 has only one fifo, so only need one instance structure */
+static struct mpc52xx_lpbfifo lpbfifo;
+
+/**
+ * mpc52xx_lpbfifo_kick - Trigger the next block of data to be transfered
+ */
+static void mpc52xx_lpbfifo_kick(struct mpc52xx_lpbfifo_request *req)
+{
+        size_t transfer_size = req->size - req->pos;
+        struct bcom_bd *bd;
+        void __iomem *reg;
+        u32 *data;
+        int i;
+        int bit_fields;
+        int dma = !(req->flags & MPC52XX_LPBFIFO_FLAG_NO_DMA);
+        int write = req->flags & MPC52XX_LPBFIFO_FLAG_WRITE;
+        int poll_dma = req->flags & MPC52XX_LPBFIFO_FLAG_POLL_DMA;
+
+        /* Set and clear the reset bits; is good practice in User Manual */
+        out_be32(lpbfifo.regs + LPBFIFO_REG_ENABLE, 0x01010000);
+
+        /* set master enable bit */
+        out_be32(lpbfifo.regs + LPBFIFO_REG_ENABLE, 0x00000001);
+        if (!dma) {
+                /* While the FIFO can be setup for transfer sizes as large as
+                 * 16M-1, the FIFO itself is only 512 bytes deep and it does
+                 * not generate interrupts for FIFO full events (only transfer
+                 * complete will raise an IRQ).  Therefore when not using
+                 * Bestcomm to drive the FIFO it needs to either be polled, or
+                 * transfers need to constrained to the size of the fifo.
+                 *
+                 * This driver restricts the size of the transfer
+                 */
+                if (transfer_size > 512)
+                        transfer_size = 512;
+
+                /* Load the FIFO with data */
+                if (write) {
+                        reg = lpbfifo.regs + LPBFIFO_REG_FIFO_DATA;
+                        data = req->data + req->pos;
+                        for (i = 0; i < transfer_size; i += 4)
+                                out_be32(reg, *data++);
+                }
+
+                /* Unmask both error and completion irqs */
+                out_be32(lpbfifo.regs + LPBFIFO_REG_ENABLE, 0x00000301);
+        } else {
+                /* Choose the correct direction
+                 *
+                 * Configure the watermarks so DMA will always complete correctly.
+                 * It may be worth experimenting with the ALARM value to see if
+                 * there is a performance impacit.  However, if it is wrong there
+                 * is a risk of DMA not transferring the last chunk of data
+                 */
+                if (write) {
+                        out_be32(lpbfifo.regs + LPBFIFO_REG_FIFO_ALARM, 0x1e4);
+                        out_8(lpbfifo.regs + LPBFIFO_REG_FIFO_CONTROL, 7);
+                        lpbfifo.bcom_cur_task = lpbfifo.bcom_tx_task;
+                } else {
+                        out_be32(lpbfifo.regs + LPBFIFO_REG_FIFO_ALARM, 0x1ff);
+                        out_8(lpbfifo.regs + LPBFIFO_REG_FIFO_CONTROL, 0);
+                        lpbfifo.bcom_cur_task = lpbfifo.bcom_rx_task;
+
+                        if (poll_dma) {
+                                if (lpbfifo.dma_irqs_enabled) {
+                                        disable_irq(bcom_get_task_irq(lpbfifo.bcom_rx_task));
+                                        lpbfifo.dma_irqs_enabled = 0;
+                                }
+                        } else {
+                                if (!lpbfifo.dma_irqs_enabled) {
+                                        enable_irq(bcom_get_task_irq(lpbfifo.bcom_rx_task));
+                                        lpbfifo.dma_irqs_enabled = 1;
+                                }
+                        }
+                }
+
+                bd = bcom_prepare_next_buffer(lpbfifo.bcom_cur_task);
+                bd->status = transfer_size;
+                if (!write) {
+                        /*
+                         * In the DMA read case, the DMA doesn't complete,
+                         * possibly due to incorrect watermarks in the ALARM
+                         * and CONTROL regs. For now instead of trying to
+                         * determine the right watermarks that will make this
+                         * work, just increase the number of bytes the FIFO is
+                         * expecting.
+                         *
+                         * When submitting another operation, the FIFO will get
+                         * reset, so the condition of the FIFO waiting for a
+                         * non-existent 4 bytes will get cleared.
+                         */
+                        transfer_size += 4; /* BLECH! */
+                }
+                bd->data[0] = req->data_phys + req->pos;
+                bcom_submit_next_buffer(lpbfifo.bcom_cur_task, NULL);
+
+                /* error irq & master enabled bit */
+                bit_fields = 0x00000201;
+
+                /* Unmask irqs */
+                if (write && (!poll_dma))
+                        bit_fields |= 0x00000100; /* completion irq too */
+                out_be32(lpbfifo.regs + LPBFIFO_REG_ENABLE, bit_fields);
+        }
+
+        /* Set transfer size, width, chip select and READ mode */
+        out_be32(lpbfifo.regs + LPBFIFO_REG_START_ADDRESS,
+                 req->offset + req->pos);
+        out_be32(lpbfifo.regs + LPBFIFO_REG_PACKET_SIZE, transfer_size);
+
+        bit_fields = req->cs << 24 | 0x000008;
+        if (!write)
+                bit_fields |= 0x010000; /* read mode */
+        out_be32(lpbfifo.regs + LPBFIFO_REG_CONTROL, bit_fields);
+
+        /* Kick it off */
+        out_8(lpbfifo.regs + LPBFIFO_REG_PACKET_SIZE, 0x01);
+        if (dma)
+                bcom_enable(lpbfifo.bcom_cur_task);
+}
+
+/**
+ * mpc52xx_lpbfifo_irq - IRQ handler for LPB FIFO
+ *
+ * On transmit, the dma completion irq triggers before the fifo completion
+ * triggers.  Handle the dma completion here instead of the LPB FIFO Bestcomm
+ * task completion irq becuase everyting is not really done until the LPB FIFO
+ * completion irq triggers.
+ *
+ * In other words:
+ * For DMA, on receive, the "Fat Lady" is the bestcom completion irq. on
+ * transmit, the fifo completion irq is the "Fat Lady". The opera (or in this
+ * case the DMA/FIFO operation) is not finished until the "Fat Lady" sings.
+ *
+ * Reasons for entering this routine:
+ * 1) PIO mode rx and tx completion irq
+ * 2) DMA interrupt mode tx completion irq
+ * 3) DMA polled mode tx
+ *
+ * Exit conditions:
+ * 1) Transfer aborted
+ * 2) FIFO complete without DMA; more data to do
+ * 3) FIFO complete without DMA; all data transfered
+ * 4) FIFO complete using DMA
+ *
+ * Condition 1 can occur regardless of whether or not DMA is used.
+ * It requires executing the callback to report the error and exiting
+ * immediately.
+ *
+ * Condition 2 requires programming the FIFO with the next block of data
+ *
+ * Condition 3 requires executing the callback to report completion
+ *
+ * Condition 4 means the same as 3, except that we also retrieve the bcom
+ * buffer so DMA doesn't get clogged up.
+ *
+ * To make things trickier, the spinlock must be dropped before
+ * executing the callback, otherwise we could end up with a deadlock
+ * or nested spinlock condition.  The out path is non-trivial, so
+ * extra fiddling is done to make sure all paths lead to the same
+ * outbound code.
+ */
+static irqreturn_t mpc52xx_lpbfifo_irq(int irq, void *dev_id)
+{
+        struct mpc52xx_lpbfifo_request *req;
+        u32 status = in_8(lpbfifo.regs + LPBFIFO_REG_BYTES_DONE_STATUS);
+        void __iomem *reg;
+        u32 *data;
+        int count, i;
+        int do_callback = 0;
+        u32 ts;
+        unsigned long flags;
+        int dma, write, poll_dma;
+
+        spin_lock_irqsave(&lpbfifo.lock, flags);
+        ts = get_tbl();
+
+        req = lpbfifo.req;
+        if (!req) {
+                spin_unlock_irqrestore(&lpbfifo.lock, flags);
+                pr_err("bogus LPBFIFO IRQ\n");
+                return IRQ_HANDLED;
+        }
+
+        dma = !(req->flags & MPC52XX_LPBFIFO_FLAG_NO_DMA);
+        write = req->flags & MPC52XX_LPBFIFO_FLAG_WRITE;
+        poll_dma = req->flags & MPC52XX_LPBFIFO_FLAG_POLL_DMA;
+
+        if (dma && !write) {
+                spin_unlock_irqrestore(&lpbfifo.lock, flags);
+                pr_err("bogus LPBFIFO IRQ (dma and not writting)\n");
+                return IRQ_HANDLED;
+        }
+
+        if ((status & 0x01) == 0) {
+                goto out;
+        }
+
+        /* check abort bit */
+        if (status & 0x10) {
+                out_be32(lpbfifo.regs + LPBFIFO_REG_ENABLE, 0x01010000);
+                do_callback = 1;
+                goto out;
+        }
+
+        /* Read result from hardware */
+        count = in_be32(lpbfifo.regs + LPBFIFO_REG_BYTES_DONE_STATUS);
+        count &= 0x00ffffff;
+
+        if (!dma && !write) {
+                /* copy the data out of the FIFO */
+                reg = lpbfifo.regs + LPBFIFO_REG_FIFO_DATA;
+                data = req->data + req->pos;
+                for (i = 0; i < count; i += 4)
+                        *data++ = in_be32(reg);
+        }
+
+        /* Update transfer position and count */
+        req->pos += count;
+
+        /* Decide what to do next */
+        if (req->size - req->pos)
+                mpc52xx_lpbfifo_kick(req); /* more work to do */
+        else
+                do_callback = 1;
+
+ out:
+        /* Clear the IRQ */
+        out_8(lpbfifo.regs + LPBFIFO_REG_BYTES_DONE_STATUS, 0x01);
+
+        if (dma && (status & 0x11)) {
+                /*
+                 * Count the DMA as complete only when the FIFO completion
+                 * status or abort bits are set.
+                 *
+                 * (status & 0x01) should always be the case except sometimes
+                 * when using polled DMA.
+                 *
+                 * (status & 0x10) {transfer aborted}: This case needs more
+                 * testing.
+                 */
+                bcom_retrieve_buffer(lpbfifo.bcom_cur_task, &status, NULL);
+        }
+        req->last_byte = ((u8 *)req->data)[req->size - 1];
+
+        /* When the do_callback flag is set; it means the transfer is finished
+         * so set the FIFO as idle */
+        if (do_callback)
+                lpbfifo.req = NULL;
+
+        if (irq != 0) /* don't increment on polled case */
+                req->irq_count++;
+
+        req->irq_ticks += get_tbl() - ts;
+        spin_unlock_irqrestore(&lpbfifo.lock, flags);
+
+        /* Spinlock is released; it is now safe to call the callback */
+        if (do_callback && req->callback)
+                req->callback(req);
+
+        return IRQ_HANDLED;
+}
+
+/**
+ * mpc52xx_lpbfifo_bcom_irq - IRQ handler for LPB FIFO Bestcomm task
+ *
+ * Only used when receiving data.
+ */
+static irqreturn_t mpc52xx_lpbfifo_bcom_irq(int irq, void *dev_id)
+{
+        struct mpc52xx_lpbfifo_request *req;
+        unsigned long flags;
+        u32 status;
+        u32 ts;
+
+        spin_lock_irqsave(&lpbfifo.lock, flags);
+        ts = get_tbl();
+
+        req = lpbfifo.req;
+        if (!req || (req->flags & MPC52XX_LPBFIFO_FLAG_NO_DMA)) {
+                spin_unlock_irqrestore(&lpbfifo.lock, flags);
+                return IRQ_HANDLED;
+        }
+
+        if (irq != 0) /* don't increment on polled case */
+                req->irq_count++;
+
+        if (!bcom_buffer_done(lpbfifo.bcom_cur_task)) {
+                spin_unlock_irqrestore(&lpbfifo.lock, flags);
+
+                req->buffer_not_done_cnt++;
+                if ((req->buffer_not_done_cnt % 1000) == 0)
+                        pr_err("transfer stalled\n");
+
+                return IRQ_HANDLED;
+        }
+
+        bcom_retrieve_buffer(lpbfifo.bcom_cur_task, &status, NULL);
+
+        req->last_byte = ((u8 *)req->data)[req->size - 1];
+
+        req->pos = status & 0x00ffffff;
+
+        /* Mark the FIFO as idle */
+        lpbfifo.req = NULL;
+
+        /* Release the lock before calling out to the callback. */
+        req->irq_ticks += get_tbl() - ts;
+        spin_unlock_irqrestore(&lpbfifo.lock, flags);
+
+        if (req->callback)
+                req->callback(req);
+
+        return IRQ_HANDLED;
+}
+
+/**
+ * mpc52xx_lpbfifo_bcom_poll - Poll for DMA completion
+ */
+void mpc52xx_lpbfifo_poll(void)
+{
+        struct mpc52xx_lpbfifo_request *req = lpbfifo.req;
+        int dma = !(req->flags & MPC52XX_LPBFIFO_FLAG_NO_DMA);
+        int write = req->flags & MPC52XX_LPBFIFO_FLAG_WRITE;
+
+        /*
+         * For more information, see comments on the "Fat Lady" 
+         */
+        if (dma && write)
+                mpc52xx_lpbfifo_irq(0, NULL);
+        else 
+                mpc52xx_lpbfifo_bcom_irq(0, NULL);
+}
+EXPORT_SYMBOL(mpc52xx_lpbfifo_poll);
+
+/**
+ * mpc52xx_lpbfifo_submit - Submit an LPB FIFO transfer request.
+ * @req: Pointer to request structure
+ */
+int mpc52xx_lpbfifo_submit(struct mpc52xx_lpbfifo_request *req)
+{
+        unsigned long flags;
+
+        if (!lpbfifo.regs)
+                return -ENODEV;
+
+        spin_lock_irqsave(&lpbfifo.lock, flags);
+
+        /* If the req pointer is already set, then a transfer is in progress */
+        if (lpbfifo.req) {
+                spin_unlock_irqrestore(&lpbfifo.lock, flags);
+                return -EBUSY;
+        }
+
+        /* Setup the transfer */
+        lpbfifo.req = req;
+        req->irq_count = 0;
+        req->irq_ticks = 0;
+        req->buffer_not_done_cnt = 0;
+        req->pos = 0;
+
+        mpc52xx_lpbfifo_kick(req);
+        spin_unlock_irqrestore(&lpbfifo.lock, flags);
+        return 0;
+}
+EXPORT_SYMBOL(mpc52xx_lpbfifo_submit);
+
+void mpc52xx_lpbfifo_abort(struct mpc52xx_lpbfifo_request *req)
+{
+        unsigned long flags;
+
+        spin_lock_irqsave(&lpbfifo.lock, flags);
+        if (lpbfifo.req == req) {
+                /* Put it into reset and clear the state */
+                bcom_gen_bd_rx_reset(lpbfifo.bcom_rx_task);
+                bcom_gen_bd_tx_reset(lpbfifo.bcom_tx_task);
+                out_be32(lpbfifo.regs + LPBFIFO_REG_ENABLE, 0x01010000);
+                lpbfifo.req = NULL;
+        }
+        spin_unlock_irqrestore(&lpbfifo.lock, flags);
+}
+EXPORT_SYMBOL(mpc52xx_lpbfifo_abort);
+
+static int __devinit
+mpc52xx_lpbfifo_probe(struct of_device *op, const struct of_device_id *match)
+{
+        struct resource res;
+        int rc = -ENOMEM;
+
+        if (lpbfifo.dev != NULL)
+                return -ENOSPC;
+
+        lpbfifo.irq = irq_of_parse_and_map(op->node, 0);
+        if (!lpbfifo.irq)
+                return -ENODEV;
+
+        if (of_address_to_resource(op->node, 0, &res))
+                return -ENODEV;
+        lpbfifo.regs_phys = res.start;
+        lpbfifo.regs = of_iomap(op->node, 0);
+        if (!lpbfifo.regs)
+                return -ENOMEM;
+
+        spin_lock_init(&lpbfifo.lock);
+
+        /* Put FIFO into reset */
+        out_be32(lpbfifo.regs + LPBFIFO_REG_ENABLE, 0x01010000);
+
+        /* Register the interrupt handler */
+        rc = request_irq(lpbfifo.irq, mpc52xx_lpbfifo_irq, 0,
+                         "mpc52xx-lpbfifo", &lpbfifo);
+        if (rc)
+                goto err_irq;
+
+        /* Request the Bestcomm receive (fifo --> memory) task and IRQ */
+        lpbfifo.bcom_rx_task =
+                bcom_gen_bd_rx_init(2, res.start + LPBFIFO_REG_FIFO_DATA,
+                                    BCOM_INITIATOR_SCLPC, BCOM_IPR_SCLPC,
+                                    16*1024*1024);
+        if (!lpbfifo.bcom_rx_task)
+                goto err_bcom_rx;
+
+        rc = request_irq(bcom_get_task_irq(lpbfifo.bcom_rx_task),
+                         mpc52xx_lpbfifo_bcom_irq, 0,
+                         "mpc52xx-lpbfifo-rx", &lpbfifo);
+        if (rc)
+                goto err_bcom_rx_irq;
+
+        /* Request the Bestcomm transmit (memory --> fifo) task and IRQ */
+        lpbfifo.bcom_tx_task =
+                bcom_gen_bd_tx_init(2, res.start + LPBFIFO_REG_FIFO_DATA,
+                                    BCOM_INITIATOR_SCLPC, BCOM_IPR_SCLPC);
+        if (!lpbfifo.bcom_tx_task)
+                goto err_bcom_tx;
+
+        lpbfifo.dev = &op->dev;
+        return 0;
+
+ err_bcom_tx:
+        free_irq(bcom_get_task_irq(lpbfifo.bcom_rx_task), &lpbfifo);
+ err_bcom_rx_irq:
+        bcom_gen_bd_rx_release(lpbfifo.bcom_rx_task);
+ err_bcom_rx:
+ err_irq:
+        iounmap(lpbfifo.regs);
+        lpbfifo.regs = NULL;
+
+        dev_err(&op->dev, "mpc52xx_lpbfifo_probe() failed\n");
+        return -ENODEV;
+}
+
+
+static int __devexit mpc52xx_lpbfifo_remove(struct of_device *op)
+{
+        if (lpbfifo.dev != &op->dev)
+                return 0;
+
+        /* Put FIFO in reset */
+        out_be32(lpbfifo.regs + LPBFIFO_REG_ENABLE, 0x01010000);
+
+        /* Release the bestcomm transmit task */
+        free_irq(bcom_get_task_irq(lpbfifo.bcom_tx_task), &lpbfifo);
+        bcom_gen_bd_tx_release(lpbfifo.bcom_tx_task);
+        
+        /* Release the bestcomm receive task */
+        free_irq(bcom_get_task_irq(lpbfifo.bcom_rx_task), &lpbfifo);
+        bcom_gen_bd_rx_release(lpbfifo.bcom_rx_task);
+
+        free_irq(lpbfifo.irq, &lpbfifo);
+        iounmap(lpbfifo.regs);
+        lpbfifo.regs = NULL;
+        lpbfifo.dev = NULL;
+
+        return 0;
+}
+
+static struct of_device_id mpc52xx_lpbfifo_match[] __devinitconst = {
+        { .compatible = "fsl,mpc5200-lpbfifo", },
+        {},
+};
+
+static struct of_platform_driver mpc52xx_lpbfifo_driver = {
+        .owner = THIS_MODULE,
+        .name = "mpc52xx-lpbfifo",
+        .match_table = mpc52xx_lpbfifo_match,
+        .probe = mpc52xx_lpbfifo_probe,
+        .remove = __devexit_p(mpc52xx_lpbfifo_remove),
+};
+
+/***********************************************************************
+ * Module init/exit
+ */
+static int __init mpc52xx_lpbfifo_init(void)
+{
+        pr_debug("Registering LocalPlus bus FIFO driver\n");
+        return of_register_platform_driver(&mpc52xx_lpbfifo_driver);
+}
+module_init(mpc52xx_lpbfifo_init);
+
+static void __exit mpc52xx_lpbfifo_exit(void)
+{
+        pr_debug("Unregistering LocalPlus bus FIFO driver\n");
+        of_unregister_platform_driver(&mpc52xx_lpbfifo_driver);
+}
+module_exit(mpc52xx_lpbfifo_exit);
diff --git a/arch/powerpc/platforms/52xx/mpc52xx_pci.c b/arch/powerpc/platforms/52xx/mpc52xx_pci.c
index dd43114e9684..da110bd88346 100644
--- a/arch/powerpc/platforms/52xx/mpc52xx_pci.c
+++ b/arch/powerpc/platforms/52xx/mpc52xx_pci.c
@@ -100,7 +100,7 @@ const struct of_device_id mpc52xx_pci_ids[] __initdata = {
 };
 
 /* ======================================================================== */
-/* PCI configuration acess                                                  */
+/* PCI configuration access                                                 */
 /* ======================================================================== */
 
 static int
diff --git a/arch/powerpc/platforms/52xx/mpc52xx_pic.c b/arch/powerpc/platforms/52xx/mpc52xx_pic.c
index 480f806fd0a9..4bf4bf7b063e 100644
--- a/arch/powerpc/platforms/52xx/mpc52xx_pic.c
+++ b/arch/powerpc/platforms/52xx/mpc52xx_pic.c
@@ -220,7 +220,7 @@ static int mpc52xx_extirq_set_type(unsigned int virq, unsigned int flow_type)
 }
 
 static struct irq_chip mpc52xx_extirq_irqchip = {
-        .typename = "MPC52xx External",
+        .name = "MPC52xx External",
         .mask = mpc52xx_extirq_mask,
         .unmask = mpc52xx_extirq_unmask,
         .ack = mpc52xx_extirq_ack,
@@ -258,7 +258,7 @@ static void mpc52xx_main_unmask(unsigned int virq)
 }
 
 static struct irq_chip mpc52xx_main_irqchip = {
-        .typename = "MPC52xx Main",
+        .name = "MPC52xx Main",
         .mask = mpc52xx_main_mask,
         .mask_ack = mpc52xx_main_mask,
         .unmask = mpc52xx_main_unmask,
@@ -291,7 +291,7 @@ static void mpc52xx_periph_unmask(unsigned int virq)
 }
 
 static struct irq_chip mpc52xx_periph_irqchip = {
-        .typename = "MPC52xx Peripherals",
+        .name = "MPC52xx Peripherals",
         .mask = mpc52xx_periph_mask,
         .mask_ack = mpc52xx_periph_mask,
         .unmask = mpc52xx_periph_unmask,
@@ -335,7 +335,7 @@ static void mpc52xx_sdma_ack(unsigned int virq)
 }
 
 static struct irq_chip mpc52xx_sdma_irqchip = {
-        .typename = "MPC52xx SDMA",
+        .name = "MPC52xx SDMA",
         .mask = mpc52xx_sdma_mask,
         .unmask = mpc52xx_sdma_unmask,
         .ack = mpc52xx_sdma_ack,
@@ -355,7 +355,7 @@ static int mpc52xx_is_extirq(int l1, int l2)
  * mpc52xx_irqhost_xlate - translate virq# from device tree interrupts property
  */
 static int mpc52xx_irqhost_xlate(struct irq_host *h, struct device_node *ct,
-                                 u32 *intspec, unsigned int intsize,
+                                 const u32 *intspec, unsigned int intsize,
                                  irq_hw_number_t *out_hwirq,
                                  unsigned int *out_flags)
 {
diff --git a/arch/powerpc/platforms/82xx/pq2ads-pci-pic.c b/arch/powerpc/platforms/82xx/pq2ads-pci-pic.c
index 7ee979f323d1..9d962d7c72c1 100644
--- a/arch/powerpc/platforms/82xx/pq2ads-pci-pic.c
+++ b/arch/powerpc/platforms/82xx/pq2ads-pci-pic.c
@@ -69,7 +69,6 @@ static void pq2ads_pci_unmask_irq(unsigned int virq)
 }
 
 static struct irq_chip pq2ads_pci_ic = {
-        .typename = "PQ2 ADS PCI",
         .name = "PQ2 ADS PCI",
         .end = pq2ads_pci_unmask_irq,
         .mask = pq2ads_pci_mask_irq,
@@ -107,7 +106,7 @@ static void pq2ads_pci_irq_demux(unsigned int irq, struct irq_desc *desc)
 static int pci_pic_host_map(struct irq_host *h, unsigned int virq,
                             irq_hw_number_t hw)
 {
-        get_irq_desc(virq)->status |= IRQ_LEVEL;
+        irq_to_desc(virq)->status |= IRQ_LEVEL;
         set_irq_chip_data(virq, h->host_data);
         set_irq_chip_and_handler(virq, &pq2ads_pci_ic, handle_level_irq);
         return 0;
diff --git a/arch/powerpc/platforms/83xx/mpc832x_rdb.c b/arch/powerpc/platforms/83xx/mpc832x_rdb.c
index 567ded7c3b9b..17f99745f0e4 100644
--- a/arch/powerpc/platforms/83xx/mpc832x_rdb.c
+++ b/arch/powerpc/platforms/83xx/mpc832x_rdb.c
@@ -74,7 +74,7 @@ static int __init of_fsl_spi_probe(char *type, char *compatible, u32 sysclk,
 
                 prop = of_get_property(np, "mode", NULL);
                 if (prop && !strcmp(prop, "cpu-qe"))
-                        pdata.qe_mode = 1;
+                        pdata.flags = SPI_QE_CPU_MODE;
 
                 for (j = 0; j < num_board_infos; j++) {
                         if (board_infos[j].bus_num == pdata.bus_num)
diff --git a/arch/powerpc/platforms/83xx/suspend.c b/arch/powerpc/platforms/83xx/suspend.c
index 08e65fc8b98c..43805348b81e 100644
--- a/arch/powerpc/platforms/83xx/suspend.c
+++ b/arch/powerpc/platforms/83xx/suspend.c
@@ -32,6 +32,7 @@
 #define PMCCR1_NEXT_STATE       0x0C /* Next state for power management */
 #define PMCCR1_NEXT_STATE_SHIFT 2
 #define PMCCR1_CURR_STATE       0x03 /* Current state for power management*/
+#define IMMR_SYSCR_OFFSET       0x100
 #define IMMR_RCW_OFFSET         0x900
 #define RCW_PCI_HOST            0x80000000
 
@@ -78,6 +79,22 @@ struct mpc83xx_clock {
         u32 sccr;
 };
 
+struct mpc83xx_syscr {
+        __be32 sgprl;
+        __be32 sgprh;
+        __be32 spridr;
+        __be32 :32;
+        __be32 spcr;
+        __be32 sicrl;
+        __be32 sicrh;
+};
+
+struct mpc83xx_saved {
+        u32 sicrl;
+        u32 sicrh;
+        u32 sccr;
+};
+
 struct pmc_type {
         int has_deep_sleep;
 };
@@ -87,6 +104,8 @@ static int has_deep_sleep, deep_sleeping;
 static int pmc_irq;
 static struct mpc83xx_pmc __iomem *pmc_regs;
 static struct mpc83xx_clock __iomem *clock_regs;
+static struct mpc83xx_syscr __iomem *syscr_regs;
+static struct mpc83xx_saved saved_regs;
 static int is_pci_agent, wake_from_pci;
 static phys_addr_t immrbase;
 static int pci_pm_state;
@@ -96,6 +115,7 @@ int fsl_deep_sleep(void)
 {
         return deep_sleeping;
 }
+EXPORT_SYMBOL(fsl_deep_sleep);
 
 static int mpc83xx_change_state(void)
 {
@@ -136,6 +156,20 @@ static irqreturn_t pmc_irq_handler(int irq, void *dev_id)
         return ret;
 }
 
+static void mpc83xx_suspend_restore_regs(void)
+{
+        out_be32(&syscr_regs->sicrl, saved_regs.sicrl);
+        out_be32(&syscr_regs->sicrh, saved_regs.sicrh);
+        out_be32(&clock_regs->sccr, saved_regs.sccr);
+}
+
+static void mpc83xx_suspend_save_regs(void)
+{
+        saved_regs.sicrl = in_be32(&syscr_regs->sicrl);
+        saved_regs.sicrh = in_be32(&syscr_regs->sicrh);
+        saved_regs.sccr = in_be32(&clock_regs->sccr);
+}
+
 static int mpc83xx_suspend_enter(suspend_state_t state)
 {
         int ret = -EAGAIN;
@@ -165,6 +199,8 @@ static int mpc83xx_suspend_enter(suspend_state_t state)
          */
 
         if (deep_sleeping) {
+                mpc83xx_suspend_save_regs();
+
                 out_be32(&pmc_regs->mask, PMCER_ALL);
 
                 out_be32(&pmc_regs->config1,
@@ -178,6 +214,8 @@ static int mpc83xx_suspend_enter(suspend_state_t state)
                          in_be32(&pmc_regs->config1) & ~PMCCR1_POWER_OFF);
 
                 out_be32(&pmc_regs->mask, PMCER_PMCI);
+
+                mpc83xx_suspend_restore_regs();
         } else {
                 out_be32(&pmc_regs->mask, PMCER_PMCI);
 
@@ -193,7 +231,7 @@ out:
         return ret;
 }
 
-static void mpc83xx_suspend_finish(void)
+static void mpc83xx_suspend_end(void)
 {
         deep_sleeping = 0;
 }
@@ -277,7 +315,7 @@ static struct platform_suspend_ops mpc83xx_suspend_ops = {
         .valid = mpc83xx_suspend_valid,
         .begin = mpc83xx_suspend_begin,
         .enter = mpc83xx_suspend_enter,
-        .finish = mpc83xx_suspend_finish,
+        .end = mpc83xx_suspend_end,
 };
 
 static int pmc_probe(struct of_device *ofdev,
@@ -332,12 +370,23 @@ static int pmc_probe(struct of_device *ofdev,
                 goto out_pmc;
         }
 
+        if (has_deep_sleep) {
+                syscr_regs = ioremap(immrbase + IMMR_SYSCR_OFFSET,
+                                     sizeof(*syscr_regs));
+                if (!syscr_regs) {
+                        ret = -ENOMEM;
+                        goto out_syscr;
+                }
+        }
+
         if (is_pci_agent)
                 mpc83xx_set_agent();
 
         suspend_set_ops(&mpc83xx_suspend_ops);
         return 0;
 
+out_syscr:
+        iounmap(clock_regs);
 out_pmc:
         iounmap(pmc_regs);
 out:
diff --git a/arch/powerpc/platforms/85xx/Kconfig b/arch/powerpc/platforms/85xx/Kconfig
index d3a975e8fd3e..d95121894eb7 100644
--- a/arch/powerpc/platforms/85xx/Kconfig
+++ b/arch/powerpc/platforms/85xx/Kconfig
@@ -1,6 +1,7 @@
-menuconfig MPC85xx
-        bool "Machine Type"
-        depends on PPC_85xx
+menuconfig FSL_SOC_BOOKE
+        bool "Freescale Book-E Machine Type"
+        depends on PPC_85xx || PPC_BOOK3E
+        select FSL_SOC
         select PPC_UDBG_16550
         select MPIC
         select PPC_PCI_CHOICE
@@ -8,7 +9,7 @@ menuconfig MPC85xx
         select SERIAL_8250_SHARE_IRQ if SERIAL_8250
         default y
 
-if MPC85xx
+if FSL_SOC_BOOKE
 
 config MPC8540_ADS
         bool "Freescale MPC8540 ADS"
@@ -144,7 +145,19 @@ config SBC8560
         help
           This option enables support for the Wind River SBC8560 board
 
-endif # MPC85xx
+config P4080_DS
+        bool "Freescale P4080 DS"
+        select DEFAULT_UIMAGE
+        select PPC_FSL_BOOK3E
+        select PPC_E500MC
+        select PHYS_64BIT
+        select SWIOTLB
+        select MPC8xxx_GPIO
+        select HAS_RAPIDIO
+        help
+          This option enables support for the P4080 DS board
+
+endif # FSL_SOC_BOOKE
 
 config TQM85xx
         bool
diff --git a/arch/powerpc/platforms/85xx/Makefile b/arch/powerpc/platforms/85xx/Makefile
index 9098aea0cf32..387c128f2c8c 100644
--- a/arch/powerpc/platforms/85xx/Makefile
+++ b/arch/powerpc/platforms/85xx/Makefile
@@ -10,6 +10,7 @@ obj-$(CONFIG_MPC8536_DS)  += mpc8536_ds.o
 obj-$(CONFIG_MPC85xx_DS)  += mpc85xx_ds.o
 obj-$(CONFIG_MPC85xx_MDS) += mpc85xx_mds.o
 obj-$(CONFIG_MPC85xx_RDB) += mpc85xx_rdb.o
+obj-$(CONFIG_P4080_DS)    += p4080_ds.o corenet_ds.o
 obj-$(CONFIG_STX_GP3)     += stx_gp3.o
 obj-$(CONFIG_TQM85xx)     += tqm85xx.o
 obj-$(CONFIG_SBC8560)     += sbc8560.o
diff --git a/arch/powerpc/platforms/85xx/corenet_ds.c b/arch/powerpc/platforms/85xx/corenet_ds.c
new file mode 100644
index 000000000000..534c2ecc89d9
--- /dev/null
+++ b/arch/powerpc/platforms/85xx/corenet_ds.c
@@ -0,0 +1,125 @@
+/*
+ * Corenet based SoC DS Setup
+ *
+ * Maintained by Kumar Gala (see MAINTAINERS for contact information)
+ *
+ * Copyright 2009 Freescale Semiconductor Inc.
+ *
+ * This program is free software; you can redistribute  it and/or modify it
+ * under  the terms of  the GNU General  Public License as published by the
+ * Free Software Foundation;  either version 2 of the  License, or (at your
+ * option) any later version.
+ */
+
+#include <linux/kernel.h>
+#include <linux/pci.h>
+#include <linux/kdev_t.h>
+#include <linux/delay.h>
+#include <linux/interrupt.h>
+#include <linux/lmb.h>
+
+#include <asm/system.h>
+#include <asm/time.h>
+#include <asm/machdep.h>
+#include <asm/pci-bridge.h>
+#include <mm/mmu_decl.h>
+#include <asm/prom.h>
+#include <asm/udbg.h>
+#include <asm/mpic.h>
+
+#include <linux/of_platform.h>
+#include <sysdev/fsl_soc.h>
+#include <sysdev/fsl_pci.h>
+
+void __init corenet_ds_pic_init(void)
+{
+        struct mpic *mpic;
+        struct resource r;
+        struct device_node *np = NULL;
+        unsigned int flags = MPIC_PRIMARY | MPIC_BIG_ENDIAN |
+                                MPIC_BROKEN_FRR_NIRQS | MPIC_SINGLE_DEST_CPU;
+
+        np = of_find_node_by_type(np, "open-pic");
+
+        if (np == NULL) {
+                printk(KERN_ERR "Could not find open-pic node\n");
+                return;
+        }
+
+        if (of_address_to_resource(np, 0, &r)) {
+                printk(KERN_ERR "Failed to map mpic register space\n");
+                of_node_put(np);
+                return;
+        }
+
+        if (ppc_md.get_irq == mpic_get_coreint_irq)
+                flags |= MPIC_ENABLE_COREINT;
+
+        mpic = mpic_alloc(np, r.start, flags, 0, 256, " OpenPIC  ");
+        BUG_ON(mpic == NULL);
+
+        mpic_init(mpic);
+}
+
+#ifdef CONFIG_PCI
+static int primary_phb_addr;
+#endif
+
+/*
+ * Setup the architecture
+ */
+#ifdef CONFIG_SMP
+void __init mpc85xx_smp_init(void);
+#endif
+
+void __init corenet_ds_setup_arch(void)
+{
+#ifdef CONFIG_PCI
+        struct device_node *np;
+        struct pci_controller *hose;
+#endif
+        dma_addr_t max = 0xffffffff;
+
+#ifdef CONFIG_SMP
+        mpc85xx_smp_init();
+#endif
+
+#ifdef CONFIG_PCI
+        for_each_compatible_node(np, "pci", "fsl,p4080-pcie") {
+                struct resource rsrc;
+                of_address_to_resource(np, 0, &rsrc);
+                if ((rsrc.start & 0xfffff) == primary_phb_addr)
+                        fsl_add_bridge(np, 1);
+                else
+                        fsl_add_bridge(np, 0);
+
+                hose = pci_find_hose_for_OF_device(np);
+                max = min(max, hose->dma_window_base_cur +
+                                hose->dma_window_size);
+        }
+#endif
+
+#ifdef CONFIG_SWIOTLB
+        if (lmb_end_of_DRAM() > max) {
+                ppc_swiotlb_enable = 1;
+                set_pci_dma_ops(&swiotlb_dma_ops);
+                ppc_md.pci_dma_dev_setup = pci_dma_dev_setup_swiotlb;
+        }
+#endif
+        pr_info("%s board from Freescale Semiconductor\n", ppc_md.name);
+}
+
+static const struct of_device_id of_device_ids[] __devinitconst = {
+        {
+                .compatible     = "simple-bus"
+        },
+        {
+                .compatible     = "fsl,rapidio-delta",
+        },
+        {}
+};
+
+int __init corenet_ds_publish_devices(void)
+{
+        return of_platform_bus_probe(NULL, of_device_ids, NULL);
+}
diff --git a/arch/powerpc/platforms/85xx/corenet_ds.h b/arch/powerpc/platforms/85xx/corenet_ds.h
new file mode 100644
index 000000000000..ddd700b23031
--- /dev/null
+++ b/arch/powerpc/platforms/85xx/corenet_ds.h
@@ -0,0 +1,19 @@
+/*
+ * Corenet based SoC DS Setup
+ *
+ * Copyright 2009 Freescale Semiconductor Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ */
+
+#ifndef CORENET_DS_H
+#define CORENET_DS_H
+
+extern void __init corenet_ds_pic_init(void);
+extern void __init corenet_ds_setup_arch(void);
+extern int __init corenet_ds_publish_devices(void);
+
+#endif
diff --git a/arch/powerpc/platforms/85xx/mpc85xx_mds.c b/arch/powerpc/platforms/85xx/mpc85xx_mds.c
index 3909d57b86e3..21f61b8c445b 100644
--- a/arch/powerpc/platforms/85xx/mpc85xx_mds.c
+++ b/arch/powerpc/platforms/85xx/mpc85xx_mds.c
@@ -86,7 +86,7 @@ static int mpc8568_fixup_125_clock(struct phy_device *phydev)
         scr = phy_read(phydev, MV88E1111_SCR);
 
         if (scr < 0)
-                return err;
+                return scr;
 
         err = phy_write(phydev, MV88E1111_SCR, scr | 0x0008);
 
@@ -301,6 +301,7 @@ static struct of_device_id mpc85xx_ids[] = {
         { .compatible = "fsl,qe", },
         { .compatible = "gianfar", },
         { .compatible = "fsl,rapidio-delta", },
+        { .compatible = "fsl,mpc8548-guts", },
         {},
 };
 
diff --git a/arch/powerpc/platforms/85xx/mpc85xx_rdb.c b/arch/powerpc/platforms/85xx/mpc85xx_rdb.c
index c8468de4acf6..088f30b0c088 100644
--- a/arch/powerpc/platforms/85xx/mpc85xx_rdb.c
+++ b/arch/powerpc/platforms/85xx/mpc85xx_rdb.c
@@ -44,6 +44,7 @@ void __init mpc85xx_rdb_pic_init(void)
         struct mpic *mpic;
         struct resource r;
         struct device_node *np;
+        unsigned long root = of_get_flat_dt_root();
 
         np = of_find_node_by_type(NULL, "open-pic");
         if (np == NULL) {
@@ -57,11 +58,18 @@ void __init mpc85xx_rdb_pic_init(void)
                 return;
         }
 
-        mpic = mpic_alloc(np, r.start,
+        if (of_flat_dt_is_compatible(root, "fsl,85XXRDB-CAMP")) {
+                mpic = mpic_alloc(np, r.start,
+                        MPIC_PRIMARY |
+                        MPIC_BIG_ENDIAN | MPIC_BROKEN_FRR_NIRQS,
+                        0, 256, " OpenPIC  ");
+        } else {
+                mpic = mpic_alloc(np, r.start,
                   MPIC_PRIMARY | MPIC_WANTS_RESET |
                   MPIC_BIG_ENDIAN | MPIC_BROKEN_FRR_NIRQS |
                   MPIC_SINGLE_DEST_CPU,
                   0, 256, " OpenPIC  ");
+        }
 
         BUG_ON(mpic == NULL);
         of_node_put(np);
@@ -113,6 +121,7 @@ static int __init mpc85xxrdb_publish_devices(void)
         return of_platform_bus_probe(NULL, mpc85xxrdb_ids, NULL);
 }
 machine_device_initcall(p2020_rdb, mpc85xxrdb_publish_devices);
+machine_device_initcall(p1020_rdb, mpc85xxrdb_publish_devices);
 
 /*
  * Called very early, device-tree isn't unflattened
@@ -126,6 +135,15 @@ static int __init p2020_rdb_probe(void)
         return 0;
 }
 
+static int __init p1020_rdb_probe(void)
+{
+        unsigned long root = of_get_flat_dt_root();
+
+        if (of_flat_dt_is_compatible(root, "fsl,P1020RDB"))
+                return 1;
+        return 0;
+}
+
 define_machine(p2020_rdb) {
         .name                   = "P2020 RDB",
         .probe                  = p2020_rdb_probe,
@@ -139,3 +157,17 @@ define_machine(p2020_rdb) {
         .calibrate_decr         = generic_calibrate_decr,
         .progress               = udbg_progress,
 };
+
+define_machine(p1020_rdb) {
+        .name                   = "P1020 RDB",
+        .probe                  = p1020_rdb_probe,
+        .setup_arch             = mpc85xx_rdb_setup_arch,
+        .init_IRQ               = mpc85xx_rdb_pic_init,
+#ifdef CONFIG_PCI
+        .pcibios_fixup_bus      = fsl_pcibios_fixup_bus,
+#endif
+        .get_irq                = mpic_get_irq,
+        .restart                = fsl_rstcr_restart,
+        .calibrate_decr         = generic_calibrate_decr,
+        .progress               = udbg_progress,
+};
diff --git a/arch/powerpc/platforms/85xx/p4080_ds.c b/arch/powerpc/platforms/85xx/p4080_ds.c
new file mode 100644
index 000000000000..84170460497b
--- /dev/null
+++ b/arch/powerpc/platforms/85xx/p4080_ds.c
@@ -0,0 +1,74 @@
+/*
+ * P4080 DS Setup
+ *
+ * Maintained by Kumar Gala (see MAINTAINERS for contact information)
+ *
+ * Copyright 2009 Freescale Semiconductor Inc.
+ *
+ * This program is free software; you can redistribute  it and/or modify it
+ * under  the terms of  the GNU General  Public License as published by the
+ * Free Software Foundation;  either version 2 of the  License, or (at your
+ * option) any later version.
+ */
+
+#include <linux/kernel.h>
+#include <linux/pci.h>
+#include <linux/kdev_t.h>
+#include <linux/delay.h>
+#include <linux/interrupt.h>
+
+#include <asm/system.h>
+#include <asm/time.h>
+#include <asm/machdep.h>
+#include <asm/pci-bridge.h>
+#include <mm/mmu_decl.h>
+#include <asm/prom.h>
+#include <asm/udbg.h>
+#include <asm/mpic.h>
+
+#include <linux/of_platform.h>
+#include <sysdev/fsl_soc.h>
+#include <sysdev/fsl_pci.h>
+
+#include "corenet_ds.h"
+
+#ifdef CONFIG_PCI
+static int primary_phb_addr;
+#endif
+
+/*
+ * Called very early, device-tree isn't unflattened
+ */
+static int __init p4080_ds_probe(void)
+{
+        unsigned long root = of_get_flat_dt_root();
+
+        if (of_flat_dt_is_compatible(root, "fsl,P4080DS")) {
+#ifdef CONFIG_PCI
+                /* treat PCIe1 as primary,
+                 * shouldn't matter as we have no ISA on the board
+                 */
+                primary_phb_addr = 0x0000;
+#endif
+                return 1;
+        } else {
+                return 0;
+        }
+}
+
+define_machine(p4080_ds) {
+        .name                   = "P4080 DS",
+        .probe                  = p4080_ds_probe,
+        .setup_arch             = corenet_ds_setup_arch,
+        .init_IRQ               = corenet_ds_pic_init,
+#ifdef CONFIG_PCI
+        .pcibios_fixup_bus      = fsl_pcibios_fixup_bus,
+#endif
+        .get_irq                = mpic_get_coreint_irq,
+        .restart                = fsl_rstcr_restart,
+        .calibrate_decr         = generic_calibrate_decr,
+        .progress               = udbg_progress,
+};
+
+machine_device_initcall(p4080_ds, corenet_ds_publish_devices);
+machine_arch_initcall(p4080_ds, swiotlb_setup_bus_notifier);
diff --git a/arch/powerpc/platforms/85xx/socrates_fpga_pic.c b/arch/powerpc/platforms/85xx/socrates_fpga_pic.c
index 60edf63d0157..e5da5f62b24a 100644
--- a/arch/powerpc/platforms/85xx/socrates_fpga_pic.c
+++ b/arch/powerpc/platforms/85xx/socrates_fpga_pic.c
@@ -232,7 +232,7 @@ static int socrates_fpga_pic_set_type(unsigned int virq,
 }
 
 static struct irq_chip socrates_fpga_pic_chip = {
-        .typename       = " FPGA-PIC ",
+        .name           = " FPGA-PIC ",
         .ack            = socrates_fpga_pic_ack,
         .mask           = socrates_fpga_pic_mask,
         .mask_ack       = socrates_fpga_pic_mask_ack,
@@ -245,7 +245,7 @@ static int socrates_fpga_pic_host_map(struct irq_host *h, unsigned int virq,
                 irq_hw_number_t hwirq)
 {
         /* All interrupts are LEVEL sensitive */
-        get_irq_desc(virq)->status |= IRQ_LEVEL;
+        irq_to_desc(virq)->status |= IRQ_LEVEL;
         set_irq_chip_and_handler(virq, &socrates_fpga_pic_chip,
                         handle_fasteoi_irq);
 
@@ -253,7 +253,7 @@ static int socrates_fpga_pic_host_map(struct irq_host *h, unsigned int virq,
 }
 
 static int socrates_fpga_pic_host_xlate(struct irq_host *h,
-                struct device_node *ct, u32 *intspec, unsigned int intsize,
+                struct device_node *ct, const u32 *intspec, unsigned int intsize,
                 irq_hw_number_t *out_hwirq, unsigned int *out_flags)
 {
         struct socrates_fpga_irq_info *fpga_irq = &fpga_irqs[intspec[0]];
diff --git a/arch/powerpc/platforms/86xx/Kconfig b/arch/powerpc/platforms/86xx/Kconfig
index 9c7b64a3402b..2bbfd530d6d8 100644
--- a/arch/powerpc/platforms/86xx/Kconfig
+++ b/arch/powerpc/platforms/86xx/Kconfig
@@ -35,6 +35,7 @@ config MPC8610_HPCD
 config GEF_PPC9A
         bool "GE Fanuc PPC9A"
         select DEFAULT_UIMAGE
+        select MMIO_NVRAM
         select GENERIC_GPIO
         select ARCH_REQUIRE_GPIOLIB
         help
@@ -43,6 +44,7 @@ config GEF_PPC9A
 config GEF_SBC310
         bool "GE Fanuc SBC310"
         select DEFAULT_UIMAGE
+        select MMIO_NVRAM
         select GENERIC_GPIO
         select ARCH_REQUIRE_GPIOLIB
         help
@@ -51,6 +53,7 @@ config GEF_SBC310
 config GEF_SBC610
         bool "GE Fanuc SBC610"
         select DEFAULT_UIMAGE
+        select MMIO_NVRAM
         select GENERIC_GPIO
         select ARCH_REQUIRE_GPIOLIB
         select HAS_RAPIDIO
diff --git a/arch/powerpc/platforms/86xx/gef_pic.c b/arch/powerpc/platforms/86xx/gef_pic.c
index 50d0a2b63809..0110a8736d33 100644
--- a/arch/powerpc/platforms/86xx/gef_pic.c
+++ b/arch/powerpc/platforms/86xx/gef_pic.c
@@ -149,7 +149,7 @@ static void gef_pic_unmask(unsigned int virq)
 }
 
 static struct irq_chip gef_pic_chip = {
-        .typename       = "gefp",
+        .name           = "gefp",
         .mask           = gef_pic_mask,
         .mask_ack       = gef_pic_mask_ack,
         .unmask         = gef_pic_unmask,
@@ -163,14 +163,14 @@ static int gef_pic_host_map(struct irq_host *h, unsigned int virq,
                           irq_hw_number_t hwirq)
 {
         /* All interrupts are LEVEL sensitive */
-        get_irq_desc(virq)->status |= IRQ_LEVEL;
+        irq_to_desc(virq)->status |= IRQ_LEVEL;
         set_irq_chip_and_handler(virq, &gef_pic_chip, handle_level_irq);
 
         return 0;
 }
 
 static int gef_pic_host_xlate(struct irq_host *h, struct device_node *ct,
-                            u32 *intspec, unsigned int intsize,
+                            const u32 *intspec, unsigned int intsize,
                             irq_hw_number_t *out_hwirq, unsigned int *out_flags)
 {
 
diff --git a/arch/powerpc/platforms/86xx/gef_ppc9a.c b/arch/powerpc/platforms/86xx/gef_ppc9a.c
index 287f7bd17dd9..a792e5d85813 100644
--- a/arch/powerpc/platforms/86xx/gef_ppc9a.c
+++ b/arch/powerpc/platforms/86xx/gef_ppc9a.c
@@ -33,6 +33,7 @@
 #include <asm/udbg.h>
 
 #include <asm/mpic.h>
+#include <asm/nvram.h>
 
 #include <sysdev/fsl_pci.h>
 #include <sysdev/fsl_soc.h>
@@ -95,6 +96,10 @@ static void __init gef_ppc9a_setup_arch(void)
                         printk(KERN_WARNING "Unable to map board registers\n");
                 of_node_put(regs);
         }
+
+#if defined(CONFIG_MMIO_NVRAM)
+        mmio_nvram_init();
+#endif
 }
 
 /* Return the PCB revision */
diff --git a/arch/powerpc/platforms/86xx/gef_sbc310.c b/arch/powerpc/platforms/86xx/gef_sbc310.c
index 90754e752bd8..6a1a613836c2 100644
--- a/arch/powerpc/platforms/86xx/gef_sbc310.c
+++ b/arch/powerpc/platforms/86xx/gef_sbc310.c
@@ -33,6 +33,7 @@
 #include <asm/udbg.h>
 
 #include <asm/mpic.h>
+#include <asm/nvram.h>
 
 #include <sysdev/fsl_pci.h>
 #include <sysdev/fsl_soc.h>
@@ -95,6 +96,10 @@ static void __init gef_sbc310_setup_arch(void)
                         printk(KERN_WARNING "Unable to map board registers\n");
                 of_node_put(regs);
         }
+
+#if defined(CONFIG_MMIO_NVRAM)
+        mmio_nvram_init();
+#endif
 }
 
 /* Return the PCB revision */
diff --git a/arch/powerpc/platforms/86xx/gef_sbc610.c b/arch/powerpc/platforms/86xx/gef_sbc610.c
index 72b31a6010a0..e10688a0fc4e 100644
--- a/arch/powerpc/platforms/86xx/gef_sbc610.c
+++ b/arch/powerpc/platforms/86xx/gef_sbc610.c
@@ -33,6 +33,7 @@
 #include <asm/udbg.h>
 
 #include <asm/mpic.h>
+#include <asm/nvram.h>
 
 #include <sysdev/fsl_pci.h>
 #include <sysdev/fsl_soc.h>
@@ -95,6 +96,10 @@ static void __init gef_sbc610_setup_arch(void)
                         printk(KERN_WARNING "Unable to map board registers\n");
                 of_node_put(regs);
         }
+
+#if defined(CONFIG_MMIO_NVRAM)
+        mmio_nvram_init();
+#endif
 }
 
 /* Return the PCB revision */
diff --git a/arch/powerpc/platforms/86xx/mpc8610_hpcd.c b/arch/powerpc/platforms/86xx/mpc8610_hpcd.c
index 627908a4cd77..5abe137f6309 100644
--- a/arch/powerpc/platforms/86xx/mpc8610_hpcd.c
+++ b/arch/powerpc/platforms/86xx/mpc8610_hpcd.c
@@ -19,6 +19,7 @@
 #include <linux/stddef.h>
 #include <linux/kernel.h>
 #include <linux/pci.h>
+#include <linux/interrupt.h>
 #include <linux/kdev_t.h>
 #include <linux/delay.h>
 #include <linux/seq_file.h>
@@ -41,10 +42,46 @@
 
 #include "mpc86xx.h"
 
+static struct device_node *pixis_node;
 static unsigned char *pixis_bdcfg0, *pixis_arch;
 
+#ifdef CONFIG_SUSPEND
+static irqreturn_t mpc8610_sw9_irq(int irq, void *data)
+{
+        pr_debug("%s: PIXIS' event (sw9/wakeup) IRQ handled\n", __func__);
+        return IRQ_HANDLED;
+}
+
+static void __init mpc8610_suspend_init(void)
+{
+        int irq;
+        int ret;
+
+        if (!pixis_node)
+                return;
+
+        irq = irq_of_parse_and_map(pixis_node, 0);
+        if (!irq) {
+                pr_err("%s: can't map pixis event IRQ.\n", __func__);
+                return;
+        }
+
+        ret = request_irq(irq, mpc8610_sw9_irq, 0, "sw9/wakeup", NULL);
+        if (ret) {
+                pr_err("%s: can't request pixis event IRQ: %d\n",
+                       __func__, ret);
+                irq_dispose_mapping(irq);
+        }
+
+        enable_irq_wake(irq);
+}
+#else
+static inline void mpc8610_suspend_init(void) { }
+#endif /* CONFIG_SUSPEND */
+
 static struct of_device_id __initdata mpc8610_ids[] = {
         { .compatible = "fsl,mpc8610-immr", },
+        { .compatible = "fsl,mpc8610-guts", },
         { .compatible = "simple-bus", },
         { .compatible = "gianfar", },
         {}
@@ -55,6 +92,9 @@ static int __init mpc8610_declare_of_platform_devices(void)
         /* Firstly, register PIXIS GPIOs. */
         simple_gpiochip_init("fsl,fpga-pixis-gpio-bank");
 
+        /* Enable wakeup on PIXIS' event IRQ. */
+        mpc8610_suspend_init();
+
         /* Without this call, the SSI device driver won't get probed. */
         of_platform_bus_probe(NULL, mpc8610_ids, NULL);
 
@@ -250,10 +290,10 @@ static void __init mpc86xx_hpcd_setup_arch(void)
         diu_ops.set_sysfs_monitor_port  = mpc8610hpcd_set_sysfs_monitor_port;
 #endif
 
-        np = of_find_compatible_node(NULL, NULL, "fsl,fpga-pixis");
-        if (np) {
-                of_address_to_resource(np, 0, &r);
-                of_node_put(np);
+        pixis_node = of_find_compatible_node(NULL, NULL, "fsl,fpga-pixis");
+        if (pixis_node) {
+                of_address_to_resource(pixis_node, 0, &r);
+                of_node_put(pixis_node);
                 pixis = ioremap(r.start, 32);
                 if (!pixis) {
                         printk(KERN_ERR "Err: can't map FPGA cfg register!\n");
diff --git a/arch/powerpc/platforms/8xx/m8xx_setup.c b/arch/powerpc/platforms/8xx/m8xx_setup.c
index 385acfc48397..242954c4293f 100644
--- a/arch/powerpc/platforms/8xx/m8xx_setup.c
+++ b/arch/powerpc/platforms/8xx/m8xx_setup.c
@@ -222,7 +222,7 @@ static void cpm_cascade(unsigned int irq, struct irq_desc *desc)
         int cascade_irq;
 
         if ((cascade_irq = cpm_get_irq()) >= 0) {
-                struct irq_desc *cdesc = irq_desc + cascade_irq;
+                struct irq_desc *cdesc = irq_to_desc(cascade_irq);
 
                 generic_handle_irq(cascade_irq);
                 cdesc->chip->eoi(cascade_irq);
diff --git a/arch/powerpc/platforms/Kconfig b/arch/powerpc/platforms/Kconfig
index 04a8061045c4..d1663db7810f 100644
--- a/arch/powerpc/platforms/Kconfig
+++ b/arch/powerpc/platforms/Kconfig
@@ -86,6 +86,11 @@ config RTAS_ERROR_LOGGING
         depends on PPC_RTAS
         default n
 
+config PPC_RTAS_DAEMON
+        bool
+        depends on PPC_RTAS
+        default n
+
 config RTAS_PROC
         bool "Proc interface to RTAS"
         depends on PPC_RTAS
@@ -255,7 +260,7 @@ config QE_GPIO
 
 config CPM2
         bool "Enable support for the CPM2 (Communications Processor Module)"
-        depends on MPC85xx || 8260
+        depends on (FSL_SOC_BOOKE && PPC32) || 8260
         select CPM
         select PPC_LIB_RHEAP
         select PPC_PCI_CHOICE
@@ -300,7 +305,7 @@ source "arch/powerpc/sysdev/bestcomm/Kconfig"
 
 config MPC8xxx_GPIO
         bool "MPC8xxx GPIO support"
-        depends on PPC_MPC831x || PPC_MPC834x || PPC_MPC837x || PPC_85xx || PPC_86xx
+        depends on PPC_MPC831x || PPC_MPC834x || PPC_MPC837x || FSL_SOC_BOOKE || PPC_86xx
         select GENERIC_GPIO
         select ARCH_REQUIRE_GPIOLIB
         help
diff --git a/arch/powerpc/platforms/Kconfig.cputype b/arch/powerpc/platforms/Kconfig.cputype
index e382cae678b8..fa0f690d3867 100644
--- a/arch/powerpc/platforms/Kconfig.cputype
+++ b/arch/powerpc/platforms/Kconfig.cputype
@@ -28,8 +28,6 @@ config PPC_BOOK3S_32
 config PPC_85xx
         bool "Freescale 85xx"
         select E500
-        select FSL_SOC
-        select MPC85xx
 
 config PPC_8xx
         bool "Freescale 8xx"
@@ -138,6 +136,14 @@ config PPC_FPU
         bool
         default y if PPC64
 
+config FSL_EMB_PERFMON
+        bool "Freescale Embedded Perfmon"
+        depends on E500 || PPC_83xx
+        help
+          This is the Performance Monitor support found on the e500 core
+          and some e300 cores (c3 and c4).  Select this only if your
+          core supports the Embedded Performance Monitor APU
+
 config 4xx
         bool
         depends on 40x || 44x
@@ -153,13 +159,6 @@ config FSL_BOOKE
         depends on E200 || E500
         default y
 
-config FSL_EMB_PERFMON
-        bool "Freescale Embedded Perfmon"
-        depends on E500 || PPC_83xx
-        help
-          This is the Performance Monitor support found on the e500 core
-          and some e300 cores (c3 and c4).  Select this only if your
-          core supports the Embedded Performance Monitor APU
 
 config PTE_64BIT
         bool
@@ -312,7 +311,7 @@ config NR_CPUS
 
 config NOT_COHERENT_CACHE
         bool
-        depends on 4xx || 8xx || E200 || PPC_MPC512x
+        depends on 4xx || 8xx || E200 || PPC_MPC512x || GAMECUBE_COMMON
         default y
 
 config CHECK_CACHE_COHERENCY
diff --git a/arch/powerpc/platforms/Makefile b/arch/powerpc/platforms/Makefile
index a6812ee00100..fdb9f0b0d7a8 100644
--- a/arch/powerpc/platforms/Makefile
+++ b/arch/powerpc/platforms/Makefile
@@ -12,7 +12,7 @@ obj-$(CONFIG_PPC_MPC52xx)	+= 52xx/
 obj-$(CONFIG_PPC_8xx)           += 8xx/
 obj-$(CONFIG_PPC_82xx)          += 82xx/
 obj-$(CONFIG_PPC_83xx)          += 83xx/
-obj-$(CONFIG_PPC_85xx)          += 85xx/
+obj-$(CONFIG_FSL_SOC_BOOKE)     += 85xx/
 obj-$(CONFIG_PPC_86xx)          += 86xx/
 obj-$(CONFIG_PPC_PSERIES)       += pseries/
 obj-$(CONFIG_PPC_ISERIES)       += iseries/
diff --git a/arch/powerpc/platforms/amigaone/setup.c b/arch/powerpc/platforms/amigaone/setup.c
index 9290a7a442d0..fb4eb0df054c 100644
--- a/arch/powerpc/platforms/amigaone/setup.c
+++ b/arch/powerpc/platforms/amigaone/setup.c
@@ -14,7 +14,7 @@
 
 #include <linux/kernel.h>
 #include <linux/seq_file.h>
-#include <linux/utsrelease.h>
+#include <generated/utsrelease.h>
 
 #include <asm/machdep.h>
 #include <asm/cputable.h>
diff --git a/arch/powerpc/platforms/cell/axon_msi.c b/arch/powerpc/platforms/cell/axon_msi.c
index a86c34b3bb84..96fe896f6df3 100644
--- a/arch/powerpc/platforms/cell/axon_msi.c
+++ b/arch/powerpc/platforms/cell/axon_msi.c
@@ -312,7 +312,7 @@ static struct irq_chip msic_irq_chip = {
         .mask           = mask_msi_irq,
         .unmask         = unmask_msi_irq,
         .shutdown       = unmask_msi_irq,
-        .typename       = "AXON-MSI",
+        .name           = "AXON-MSI",
 };
 
 static int msic_host_map(struct irq_host *h, unsigned int virq,
diff --git a/arch/powerpc/platforms/cell/beat_interrupt.c b/arch/powerpc/platforms/cell/beat_interrupt.c
index 72254848a228..36052a9ebcda 100644
--- a/arch/powerpc/platforms/cell/beat_interrupt.c
+++ b/arch/powerpc/platforms/cell/beat_interrupt.c
@@ -110,7 +110,7 @@ static void beatic_end_irq(unsigned int irq_plug)
 }
 
 static struct irq_chip beatic_pic = {
-        .typename = " CELL-BEAT ",
+        .name = " CELL-BEAT ",
         .unmask = beatic_unmask_irq,
         .mask = beatic_mask_irq,
         .eoi = beatic_end_irq,
@@ -136,7 +136,7 @@ static void beatic_pic_host_unmap(struct irq_host *h, unsigned int virq)
 static int beatic_pic_host_map(struct irq_host *h, unsigned int virq,
                                irq_hw_number_t hw)
 {
-        struct irq_desc *desc = get_irq_desc(virq);
+        struct irq_desc *desc = irq_to_desc(virq);
         int64_t err;
 
         err = beat_construct_and_connect_irq_plug(virq, hw);
@@ -166,11 +166,11 @@ static void beatic_pic_host_remap(struct irq_host *h, unsigned int virq,
  * Note: We have only 1 entry to translate.
  */
 static int beatic_pic_host_xlate(struct irq_host *h, struct device_node *ct,
-                                 u32 *intspec, unsigned int intsize,
+                                 const u32 *intspec, unsigned int intsize,
                                  irq_hw_number_t *out_hwirq,
                                  unsigned int *out_flags)
 {
-        u64 *intspec2 = (u64 *)intspec;
+        const u64 *intspec2 = (const u64 *)intspec;
 
         *out_hwirq = *intspec2;
         *out_flags |= IRQ_TYPE_LEVEL_LOW;
diff --git a/arch/powerpc/platforms/cell/interrupt.c b/arch/powerpc/platforms/cell/interrupt.c
index 882e47080e74..6829cf7e2bda 100644
--- a/arch/powerpc/platforms/cell/interrupt.c
+++ b/arch/powerpc/platforms/cell/interrupt.c
@@ -54,7 +54,7 @@ struct iic {
         struct device_node *node;
 };
 
-static DEFINE_PER_CPU(struct iic, iic);
+static DEFINE_PER_CPU(struct iic, cpu_iic);
 #define IIC_NODE_COUNT  2
 static struct irq_host *iic_host;
 
@@ -82,13 +82,13 @@ static void iic_unmask(unsigned int irq)
 
 static void iic_eoi(unsigned int irq)
 {
-        struct iic *iic = &__get_cpu_var(iic);
+        struct iic *iic = &__get_cpu_var(cpu_iic);
         out_be64(&iic->regs->prio, iic->eoi_stack[--iic->eoi_ptr]);
         BUG_ON(iic->eoi_ptr < 0);
 }
 
 static struct irq_chip iic_chip = {
-        .typename = " CELL-IIC ",
+        .name = " CELL-IIC ",
         .mask = iic_mask,
         .unmask = iic_unmask,
         .eoi = iic_eoi,
@@ -133,7 +133,7 @@ static void iic_ioexc_cascade(unsigned int irq, struct irq_desc *desc)
 
 
 static struct irq_chip iic_ioexc_chip = {
-        .typename = " CELL-IOEX",
+        .name = " CELL-IOEX",
         .mask = iic_mask,
         .unmask = iic_unmask,
         .eoi = iic_ioexc_eoi,
@@ -146,7 +146,7 @@ static unsigned int iic_get_irq(void)
         struct iic *iic;
         unsigned int virq;
 
-        iic = &__get_cpu_var(iic);
+        iic = &__get_cpu_var(cpu_iic);
         *(unsigned long *) &pending =
                 in_be64((u64 __iomem *) &iic->regs->pending_destr);
         if (!(pending.flags & CBE_IIC_IRQ_VALID))
@@ -161,12 +161,12 @@ static unsigned int iic_get_irq(void)
 
 void iic_setup_cpu(void)
 {
-        out_be64(&__get_cpu_var(iic).regs->prio, 0xff);
+        out_be64(&__get_cpu_var(cpu_iic).regs->prio, 0xff);
 }
 
 u8 iic_get_target_id(int cpu)
 {
-        return per_cpu(iic, cpu).target_id;
+        return per_cpu(cpu_iic, cpu).target_id;
 }
 
 EXPORT_SYMBOL_GPL(iic_get_target_id);
@@ -181,7 +181,7 @@ static inline int iic_ipi_to_irq(int ipi)
 
 void iic_cause_IPI(int cpu, int mesg)
 {
-        out_be64(&per_cpu(iic, cpu).regs->generate, (0xf - mesg) << 4);
+        out_be64(&per_cpu(cpu_iic, cpu).regs->generate, (0xf - mesg) << 4);
 }
 
 struct irq_host *iic_get_irq_host(int node)
@@ -237,7 +237,7 @@ extern int noirqdebug;
 
 static void handle_iic_irq(unsigned int irq, struct irq_desc *desc)
 {
-        spin_lock(&desc->lock);
+        raw_spin_lock(&desc->lock);
 
         desc->status &= ~(IRQ_REPLAY | IRQ_WAITING);
 
@@ -265,18 +265,18 @@ static void handle_iic_irq(unsigned int irq, struct irq_desc *desc)
                         goto out_eoi;
 
                 desc->status &= ~IRQ_PENDING;
-                spin_unlock(&desc->lock);
+                raw_spin_unlock(&desc->lock);
                 action_ret = handle_IRQ_event(irq, action);
                 if (!noirqdebug)
                         note_interrupt(irq, desc, action_ret);
-                spin_lock(&desc->lock);
+                raw_spin_lock(&desc->lock);
 
         } while ((desc->status & (IRQ_PENDING | IRQ_DISABLED)) == IRQ_PENDING);
 
         desc->status &= ~IRQ_INPROGRESS;
 out_eoi:
         desc->chip->eoi(irq);
-        spin_unlock(&desc->lock);
+        raw_spin_unlock(&desc->lock);
 }
 
 static int iic_host_map(struct irq_host *h, unsigned int virq,
@@ -297,7 +297,7 @@ static int iic_host_map(struct irq_host *h, unsigned int virq,
 }
 
 static int iic_host_xlate(struct irq_host *h, struct device_node *ct,
-                           u32 *intspec, unsigned int intsize,
+                           const u32 *intspec, unsigned int intsize,
                            irq_hw_number_t *out_hwirq, unsigned int *out_flags)
 
 {
@@ -348,7 +348,7 @@ static void __init init_one_iic(unsigned int hw_cpu, unsigned long addr,
         /* XXX FIXME: should locate the linux CPU number from the HW cpu
          * number properly. We are lucky for now
          */
-        struct iic *iic = &per_cpu(iic, hw_cpu);
+        struct iic *iic = &per_cpu(cpu_iic, hw_cpu);
 
         iic->regs = ioremap(addr, sizeof(struct cbe_iic_thread_regs));
         BUG_ON(iic->regs == NULL);
diff --git a/arch/powerpc/platforms/cell/spider-pic.c b/arch/powerpc/platforms/cell/spider-pic.c
index 4e5655624ae8..01244f254a11 100644
--- a/arch/powerpc/platforms/cell/spider-pic.c
+++ b/arch/powerpc/platforms/cell/spider-pic.c
@@ -102,7 +102,7 @@ static void spider_ack_irq(unsigned int virq)
 
         /* Reset edge detection logic if necessary
          */
-        if (get_irq_desc(virq)->status & IRQ_LEVEL)
+        if (irq_to_desc(virq)->status & IRQ_LEVEL)
                 return;
 
         /* Only interrupts 47 to 50 can be set to edge */
@@ -119,7 +119,7 @@ static int spider_set_irq_type(unsigned int virq, unsigned int type)
         struct spider_pic *pic = spider_virq_to_pic(virq);
         unsigned int hw = irq_map[virq].hwirq;
         void __iomem *cfg = spider_get_irq_config(pic, hw);
-        struct irq_desc *desc = get_irq_desc(virq);
+        struct irq_desc *desc = irq_to_desc(virq);
         u32 old_mask;
         u32 ic;
 
@@ -168,7 +168,7 @@ static int spider_set_irq_type(unsigned int virq, unsigned int type)
 }
 
 static struct irq_chip spider_pic = {
-        .typename = " SPIDER   ",
+        .name = " SPIDER   ",
         .unmask = spider_unmask_irq,
         .mask = spider_mask_irq,
         .ack = spider_ack_irq,
@@ -187,7 +187,7 @@ static int spider_host_map(struct irq_host *h, unsigned int virq,
 }
 
 static int spider_host_xlate(struct irq_host *h, struct device_node *ct,
-                           u32 *intspec, unsigned int intsize,
+                           const u32 *intspec, unsigned int intsize,
                            irq_hw_number_t *out_hwirq, unsigned int *out_flags)
 
 {
diff --git a/arch/powerpc/platforms/cell/spufs/Makefile b/arch/powerpc/platforms/cell/spufs/Makefile
index b93f877ba504..b9d5d678aa44 100644
--- a/arch/powerpc/platforms/cell/spufs/Makefile
+++ b/arch/powerpc/platforms/cell/spufs/Makefile
@@ -13,10 +13,8 @@ SPU_CC		:= $(SPU_CROSS)gcc
 SPU_AS          := $(SPU_CROSS)gcc
 SPU_LD          := $(SPU_CROSS)ld
 SPU_OBJCOPY     := $(SPU_CROSS)objcopy
-SPU_CFLAGS      := -O2 -Wall -I$(srctree)/include \
-                   -I$(objtree)/include2 -D__KERNEL__
-SPU_AFLAGS      := -c -D__ASSEMBLY__ -I$(srctree)/include \
-                   -I$(objtree)/include2 -D__KERNEL__
+SPU_CFLAGS      := -O2 -Wall -I$(srctree)/include -D__KERNEL__
+SPU_AFLAGS      := -c -D__ASSEMBLY__ -I$(srctree)/include -D__KERNEL__
 SPU_LDFLAGS     := -N -Ttext=0x0
 
 $(obj)/switch.o: $(obj)/spu_save_dump.h $(obj)/spu_restore_dump.h
diff --git a/arch/powerpc/platforms/cell/spufs/coredump.c b/arch/powerpc/platforms/cell/spufs/coredump.c
index c4d4a19235e0..eea120229cdb 100644
--- a/arch/powerpc/platforms/cell/spufs/coredump.c
+++ b/arch/powerpc/platforms/cell/spufs/coredump.c
@@ -54,7 +54,7 @@ static ssize_t do_coredump_read(int num, struct spu_context *ctx, void *buffer,
  */
 static int spufs_dump_write(struct file *file, const void *addr, int nr, loff_t *foffset)
 {
-        unsigned long limit = current->signal->rlim[RLIMIT_CORE].rlim_cur;
+        unsigned long limit = rlimit(RLIMIT_CORE);
         ssize_t written;
 
         if (*foffset + nr > limit)
diff --git a/arch/powerpc/platforms/cell/spufs/file.c b/arch/powerpc/platforms/cell/spufs/file.c
index 884e8bcec499..64a4c2d85f7c 100644
--- a/arch/powerpc/platforms/cell/spufs/file.c
+++ b/arch/powerpc/platforms/cell/spufs/file.c
@@ -2494,7 +2494,7 @@ static ssize_t spufs_switch_log_read(struct file *file, char __user *buf,
         struct spu_context *ctx = SPUFS_I(inode)->i_ctx;
         int error = 0, cnt = 0;
 
-        if (!buf || len < 0)
+        if (!buf)
                 return -EINVAL;
 
         error = spu_acquire(ctx);
diff --git a/arch/powerpc/platforms/chrp/Kconfig b/arch/powerpc/platforms/chrp/Kconfig
index 37d438bd5b7a..bc0b0efdc5fe 100644
--- a/arch/powerpc/platforms/chrp/Kconfig
+++ b/arch/powerpc/platforms/chrp/Kconfig
@@ -5,6 +5,8 @@ config PPC_CHRP
         select PPC_I8259
         select PPC_INDIRECT_PCI
         select PPC_RTAS
+        select PPC_RTAS_DAEMON
+        select RTAS_ERROR_LOGGING
         select PPC_MPC106
         select PPC_UDBG_16550
         select PPC_NATIVE
diff --git a/arch/powerpc/platforms/chrp/setup.c b/arch/powerpc/platforms/chrp/setup.c
index cd4ad9aea760..8f41685d8f42 100644
--- a/arch/powerpc/platforms/chrp/setup.c
+++ b/arch/powerpc/platforms/chrp/setup.c
@@ -23,7 +23,7 @@
 #include <linux/reboot.h>
 #include <linux/init.h>
 #include <linux/pci.h>
-#include <linux/utsrelease.h>
+#include <generated/utsrelease.h>
 #include <linux/adb.h>
 #include <linux/module.h>
 #include <linux/delay.h>
@@ -364,19 +364,6 @@ void __init chrp_setup_arch(void)
         if (ppc_md.progress) ppc_md.progress("Linux/PPC "UTS_RELEASE"\n", 0x0);
 }
 
-void
-chrp_event_scan(unsigned long unused)
-{
-        unsigned char log[1024];
-        int ret = 0;
-
-        /* XXX: we should loop until the hardware says no more error logs -- Cort */
-        rtas_call(rtas_token("event-scan"), 4, 1, &ret, 0xffffffff, 0,
-                  __pa(log), 1024);
-        mod_timer(&__get_cpu_var(heartbeat_timer),
-                  jiffies + event_scan_interval);
-}
-
 static void chrp_8259_cascade(unsigned int irq, struct irq_desc *desc)
 {
         unsigned int cascade_irq = i8259_irq();
@@ -568,9 +555,6 @@ void __init chrp_init_IRQ(void)
 void __init
 chrp_init2(void)
 {
-        struct device_node *device;
-        const unsigned int *p = NULL;
-
 #ifdef CONFIG_NVRAM
         chrp_nvram_init();
 #endif
@@ -582,40 +566,6 @@ chrp_init2(void)
         request_region(0x80,0x10,"dma page reg");
         request_region(0xc0,0x20,"dma2");
 
-        /* Get the event scan rate for the rtas so we know how
-         * often it expects a heartbeat. -- Cort
-         */
-        device = of_find_node_by_name(NULL, "rtas");
-        if (device)
-                p = of_get_property(device, "rtas-event-scan-rate", NULL);
-        if (p && *p) {
-                /*
-                 * Arrange to call chrp_event_scan at least *p times
-                 * per minute.  We use 59 rather than 60 here so that
-                 * the rate will be slightly higher than the minimum.
-                 * This all assumes we don't do hotplug CPU on any
-                 * machine that needs the event scans done.
-                 */
-                unsigned long interval, offset;
-                int cpu, ncpus;
-                struct timer_list *timer;
-
-                interval = HZ * 59 / *p;
-                offset = HZ;
-                ncpus = num_online_cpus();
-                event_scan_interval = ncpus * interval;
-                for (cpu = 0; cpu < ncpus; ++cpu) {
-                        timer = &per_cpu(heartbeat_timer, cpu);
-                        setup_timer(timer, chrp_event_scan, 0);
-                        timer->expires = jiffies + offset;
-                        add_timer_on(timer, cpu);
-                        offset += interval;
-                }
-                printk("RTAS Event Scan Rate: %u (%lu jiffies)\n",
-                       *p, interval);
-        }
-        of_node_put(device);
-
         if (ppc_md.progress)
                 ppc_md.progress("  Have fun!    ", 0x7777);
 }
diff --git a/arch/powerpc/platforms/embedded6xx/Kconfig b/arch/powerpc/platforms/embedded6xx/Kconfig
index 291ac9d8cbee..524d971a1478 100644
--- a/arch/powerpc/platforms/embedded6xx/Kconfig
+++ b/arch/powerpc/platforms/embedded6xx/Kconfig
@@ -90,3 +90,36 @@ config MPC10X_OPENPIC
 config MPC10X_STORE_GATHERING
         bool "Enable MPC10x store gathering"
         depends on MPC10X_BRIDGE
+
+config GAMECUBE_COMMON
+        bool
+
+config USBGECKO_UDBG
+        bool "USB Gecko udbg console for the Nintendo GameCube/Wii"
+        depends on GAMECUBE_COMMON
+        help
+          If you say yes to this option, support will be included for the
+          USB Gecko adapter as an udbg console.
+          The USB Gecko is a EXI to USB Serial converter that can be plugged
+          into a memcard slot in the Nintendo GameCube/Wii.
+
+          This driver bypasses the EXI layer completely.
+
+          If in doubt, say N here.
+
+config GAMECUBE
+        bool "Nintendo-GameCube"
+        depends on EMBEDDED6xx
+        select GAMECUBE_COMMON
+        help
+          Select GAMECUBE if configuring for the Nintendo GameCube.
+          More information at: <http://gc-linux.sourceforge.net/>
+
+config WII
+        bool "Nintendo-Wii"
+        depends on EMBEDDED6xx
+        select GAMECUBE_COMMON
+        help
+          Select WII if configuring for the Nintendo Wii.
+          More information at: <http://gc-linux.sourceforge.net/>
+
diff --git a/arch/powerpc/platforms/embedded6xx/Makefile b/arch/powerpc/platforms/embedded6xx/Makefile
index 0773c08bd444..66c23e423f40 100644
--- a/arch/powerpc/platforms/embedded6xx/Makefile
+++ b/arch/powerpc/platforms/embedded6xx/Makefile
@@ -7,3 +7,7 @@ obj-$(CONFIG_STORCENTER)	+= storcenter.o
 obj-$(CONFIG_PPC_HOLLY)         += holly.o
 obj-$(CONFIG_PPC_PRPMC2800)     += prpmc2800.o
 obj-$(CONFIG_PPC_C2K)           += c2k.o
+obj-$(CONFIG_USBGECKO_UDBG)     += usbgecko_udbg.o
+obj-$(CONFIG_GAMECUBE_COMMON)   += flipper-pic.o
+obj-$(CONFIG_GAMECUBE)          += gamecube.o
+obj-$(CONFIG_WII)               += wii.o hlwd-pic.o
diff --git a/arch/powerpc/platforms/embedded6xx/flipper-pic.c b/arch/powerpc/platforms/embedded6xx/flipper-pic.c
new file mode 100644
index 000000000000..c278bd3a8fec
--- /dev/null
+++ b/arch/powerpc/platforms/embedded6xx/flipper-pic.c
@@ -0,0 +1,263 @@
+/*
+ * arch/powerpc/platforms/embedded6xx/flipper-pic.c
+ *
+ * Nintendo GameCube/Wii "Flipper" interrupt controller support.
+ * Copyright (C) 2004-2009 The GameCube Linux Team
+ * Copyright (C) 2007,2008,2009 Albert Herranz
+ *
+ * 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.
+ *
+ */
+#define DRV_MODULE_NAME "flipper-pic"
+#define pr_fmt(fmt) DRV_MODULE_NAME ": " fmt
+
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/irq.h>
+#include <linux/of.h>
+#include <asm/io.h>
+
+#include "flipper-pic.h"
+
+#define FLIPPER_NR_IRQS         32
+
+/*
+ * Each interrupt has a corresponding bit in both
+ * the Interrupt Cause (ICR) and Interrupt Mask (IMR) registers.
+ *
+ * Enabling/disabling an interrupt line involves setting/clearing
+ * the corresponding bit in IMR.
+ * Except for the RSW interrupt, all interrupts get deasserted automatically
+ * when the source deasserts the interrupt.
+ */
+#define FLIPPER_ICR             0x00
+#define FLIPPER_ICR_RSS         (1<<16) /* reset switch state */
+
+#define FLIPPER_IMR             0x04
+
+#define FLIPPER_RESET           0x24
+
+
+/*
+ * IRQ chip hooks.
+ *
+ */
+
+static void flipper_pic_mask_and_ack(unsigned int virq)
+{
+        int irq = virq_to_hw(virq);
+        void __iomem *io_base = get_irq_chip_data(virq);
+        u32 mask = 1 << irq;
+
+        clrbits32(io_base + FLIPPER_IMR, mask);
+        /* this is at least needed for RSW */
+        out_be32(io_base + FLIPPER_ICR, mask);
+}
+
+static void flipper_pic_ack(unsigned int virq)
+{
+        int irq = virq_to_hw(virq);
+        void __iomem *io_base = get_irq_chip_data(virq);
+
+        /* this is at least needed for RSW */
+        out_be32(io_base + FLIPPER_ICR, 1 << irq);
+}
+
+static void flipper_pic_mask(unsigned int virq)
+{
+        int irq = virq_to_hw(virq);
+        void __iomem *io_base = get_irq_chip_data(virq);
+
+        clrbits32(io_base + FLIPPER_IMR, 1 << irq);
+}
+
+static void flipper_pic_unmask(unsigned int virq)
+{
+        int irq = virq_to_hw(virq);
+        void __iomem *io_base = get_irq_chip_data(virq);
+
+        setbits32(io_base + FLIPPER_IMR, 1 << irq);
+}
+
+
+static struct irq_chip flipper_pic = {
+        .name           = "flipper-pic",
+        .ack            = flipper_pic_ack,
+        .mask_ack       = flipper_pic_mask_and_ack,
+        .mask           = flipper_pic_mask,
+        .unmask         = flipper_pic_unmask,
+};
+
+/*
+ * IRQ host hooks.
+ *
+ */
+
+static struct irq_host *flipper_irq_host;
+
+static int flipper_pic_map(struct irq_host *h, unsigned int virq,
+                           irq_hw_number_t hwirq)
+{
+        set_irq_chip_data(virq, h->host_data);
+        irq_to_desc(virq)->status |= IRQ_LEVEL;
+        set_irq_chip_and_handler(virq, &flipper_pic, handle_level_irq);
+        return 0;
+}
+
+static void flipper_pic_unmap(struct irq_host *h, unsigned int irq)
+{
+        set_irq_chip_data(irq, NULL);
+        set_irq_chip(irq, NULL);
+}
+
+static int flipper_pic_match(struct irq_host *h, struct device_node *np)
+{
+        return 1;
+}
+
+
+static struct irq_host_ops flipper_irq_host_ops = {
+        .map = flipper_pic_map,
+        .unmap = flipper_pic_unmap,
+        .match = flipper_pic_match,
+};
+
+/*
+ * Platform hooks.
+ *
+ */
+
+static void __flipper_quiesce(void __iomem *io_base)
+{
+        /* mask and ack all IRQs */
+        out_be32(io_base + FLIPPER_IMR, 0x00000000);
+        out_be32(io_base + FLIPPER_ICR, 0xffffffff);
+}
+
+struct irq_host * __init flipper_pic_init(struct device_node *np)
+{
+        struct device_node *pi;
+        struct irq_host *irq_host = NULL;
+        struct resource res;
+        void __iomem *io_base;
+        int retval;
+
+        pi = of_get_parent(np);
+        if (!pi) {
+                pr_err("no parent found\n");
+                goto out;
+        }
+        if (!of_device_is_compatible(pi, "nintendo,flipper-pi")) {
+                pr_err("unexpected parent compatible\n");
+                goto out;
+        }
+
+        retval = of_address_to_resource(pi, 0, &res);
+        if (retval) {
+                pr_err("no io memory range found\n");
+                goto out;
+        }
+        io_base = ioremap(res.start, resource_size(&res));
+
+        pr_info("controller at 0x%08x mapped to 0x%p\n", res.start, io_base);
+
+        __flipper_quiesce(io_base);
+
+        irq_host = irq_alloc_host(np, IRQ_HOST_MAP_LINEAR, FLIPPER_NR_IRQS,
+                                  &flipper_irq_host_ops, -1);
+        if (!irq_host) {
+                pr_err("failed to allocate irq_host\n");
+                return NULL;
+        }
+
+        irq_host->host_data = io_base;
+
+out:
+        return irq_host;
+}
+
+unsigned int flipper_pic_get_irq(void)
+{
+        void __iomem *io_base = flipper_irq_host->host_data;
+        int irq;
+        u32 irq_status;
+
+        irq_status = in_be32(io_base + FLIPPER_ICR) &
+                     in_be32(io_base + FLIPPER_IMR);
+        if (irq_status == 0)
+                return NO_IRQ;  /* no more IRQs pending */
+
+        irq = __ffs(irq_status);
+        return irq_linear_revmap(flipper_irq_host, irq);
+}
+
+/*
+ * Probe function.
+ *
+ */
+
+void __init flipper_pic_probe(void)
+{
+        struct device_node *np;
+
+        np = of_find_compatible_node(NULL, NULL, "nintendo,flipper-pic");
+        BUG_ON(!np);
+
+        flipper_irq_host = flipper_pic_init(np);
+        BUG_ON(!flipper_irq_host);
+
+        irq_set_default_host(flipper_irq_host);
+
+        of_node_put(np);
+}
+
+/*
+ * Misc functions related to the flipper chipset.
+ *
+ */
+
+/**
+ * flipper_quiesce() - quiesce flipper irq controller
+ *
+ * Mask and ack all interrupt sources.
+ *
+ */
+void flipper_quiesce(void)
+{
+        void __iomem *io_base = flipper_irq_host->host_data;
+
+        __flipper_quiesce(io_base);
+}
+
+/*
+ * Resets the platform.
+ */
+void flipper_platform_reset(void)
+{
+        void __iomem *io_base;
+
+        if (flipper_irq_host && flipper_irq_host->host_data) {
+                io_base = flipper_irq_host->host_data;
+                out_8(io_base + FLIPPER_RESET, 0x00);
+        }
+}
+
+/*
+ * Returns non-zero if the reset button is pressed.
+ */
+int flipper_is_reset_button_pressed(void)
+{
+        void __iomem *io_base;
+        u32 icr;
+
+        if (flipper_irq_host && flipper_irq_host->host_data) {
+                io_base = flipper_irq_host->host_data;
+                icr = in_be32(io_base + FLIPPER_ICR);
+                return !(icr & FLIPPER_ICR_RSS);
+        }
+        return 0;
+}
+
diff --git a/arch/powerpc/platforms/embedded6xx/flipper-pic.h b/arch/powerpc/platforms/embedded6xx/flipper-pic.h
new file mode 100644
index 000000000000..e339186b5663
--- /dev/null
+++ b/arch/powerpc/platforms/embedded6xx/flipper-pic.h
@@ -0,0 +1,25 @@
+/*
+ * arch/powerpc/platforms/embedded6xx/flipper-pic.h
+ *
+ * Nintendo GameCube/Wii "Flipper" interrupt controller support.
+ * Copyright (C) 2004-2009 The GameCube Linux Team
+ * Copyright (C) 2007,2008,2009 Albert Herranz
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ */
+
+#ifndef __FLIPPER_PIC_H
+#define __FLIPPER_PIC_H
+
+unsigned int flipper_pic_get_irq(void);
+void __init flipper_pic_probe(void);
+
+void flipper_quiesce(void);
+void flipper_platform_reset(void);
+int flipper_is_reset_button_pressed(void);
+
+#endif
diff --git a/arch/powerpc/platforms/embedded6xx/gamecube.c b/arch/powerpc/platforms/embedded6xx/gamecube.c
new file mode 100644
index 000000000000..1106fd99627f
--- /dev/null
+++ b/arch/powerpc/platforms/embedded6xx/gamecube.c
@@ -0,0 +1,118 @@
+/*
+ * arch/powerpc/platforms/embedded6xx/gamecube.c
+ *
+ * Nintendo GameCube board-specific support
+ * Copyright (C) 2004-2009 The GameCube Linux Team
+ * Copyright (C) 2007,2008,2009 Albert Herranz
+ *
+ * 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/init.h>
+#include <linux/irq.h>
+#include <linux/kexec.h>
+#include <linux/seq_file.h>
+#include <linux/of_platform.h>
+
+#include <asm/io.h>
+#include <asm/machdep.h>
+#include <asm/prom.h>
+#include <asm/time.h>
+#include <asm/udbg.h>
+
+#include "flipper-pic.h"
+#include "usbgecko_udbg.h"
+
+
+static void gamecube_spin(void)
+{
+        /* spin until power button pressed */
+        for (;;)
+                cpu_relax();
+}
+
+static void gamecube_restart(char *cmd)
+{
+        local_irq_disable();
+        flipper_platform_reset();
+        gamecube_spin();
+}
+
+static void gamecube_power_off(void)
+{
+        local_irq_disable();
+        gamecube_spin();
+}
+
+static void gamecube_halt(void)
+{
+        gamecube_restart(NULL);
+}
+
+static void __init gamecube_init_early(void)
+{
+        ug_udbg_init();
+}
+
+static int __init gamecube_probe(void)
+{
+        unsigned long dt_root;
+
+        dt_root = of_get_flat_dt_root();
+        if (!of_flat_dt_is_compatible(dt_root, "nintendo,gamecube"))
+                return 0;
+
+        return 1;
+}
+
+static void gamecube_shutdown(void)
+{
+        flipper_quiesce();
+}
+
+#ifdef CONFIG_KEXEC
+static int gamecube_kexec_prepare(struct kimage *image)
+{
+        return 0;
+}
+#endif /* CONFIG_KEXEC */
+
+
+define_machine(gamecube) {
+        .name                   = "gamecube",
+        .probe                  = gamecube_probe,
+        .init_early             = gamecube_init_early,
+        .restart                = gamecube_restart,
+        .power_off              = gamecube_power_off,
+        .halt                   = gamecube_halt,
+        .init_IRQ               = flipper_pic_probe,
+        .get_irq                = flipper_pic_get_irq,
+        .calibrate_decr         = generic_calibrate_decr,
+        .progress               = udbg_progress,
+        .machine_shutdown       = gamecube_shutdown,
+#ifdef CONFIG_KEXEC
+        .machine_kexec_prepare  = gamecube_kexec_prepare,
+#endif
+};
+
+
+static struct of_device_id gamecube_of_bus[] = {
+        { .compatible = "nintendo,flipper", },
+        { },
+};
+
+static int __init gamecube_device_probe(void)
+{
+        if (!machine_is(gamecube))
+                return 0;
+
+        of_platform_bus_probe(NULL, gamecube_of_bus, NULL);
+        return 0;
+}
+device_initcall(gamecube_device_probe);
+
diff --git a/arch/powerpc/platforms/embedded6xx/hlwd-pic.c b/arch/powerpc/platforms/embedded6xx/hlwd-pic.c
new file mode 100644
index 000000000000..a771f91e215b
--- /dev/null
+++ b/arch/powerpc/platforms/embedded6xx/hlwd-pic.c
@@ -0,0 +1,241 @@
+/*
+ * arch/powerpc/platforms/embedded6xx/hlwd-pic.c
+ *
+ * Nintendo Wii "Hollywood" interrupt controller support.
+ * Copyright (C) 2009 The GameCube Linux Team
+ * Copyright (C) 2009 Albert Herranz
+ *
+ * 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.
+ *
+ */
+#define DRV_MODULE_NAME "hlwd-pic"
+#define pr_fmt(fmt) DRV_MODULE_NAME ": " fmt
+
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/irq.h>
+#include <linux/of.h>
+#include <asm/io.h>
+
+#include "hlwd-pic.h"
+
+#define HLWD_NR_IRQS    32
+
+/*
+ * Each interrupt has a corresponding bit in both
+ * the Interrupt Cause (ICR) and Interrupt Mask (IMR) registers.
+ *
+ * Enabling/disabling an interrupt line involves asserting/clearing
+ * the corresponding bit in IMR. ACK'ing a request simply involves
+ * asserting the corresponding bit in ICR.
+ */
+#define HW_BROADWAY_ICR         0x00
+#define HW_BROADWAY_IMR         0x04
+
+
+/*
+ * IRQ chip hooks.
+ *
+ */
+
+static void hlwd_pic_mask_and_ack(unsigned int virq)
+{
+        int irq = virq_to_hw(virq);
+        void __iomem *io_base = get_irq_chip_data(virq);
+        u32 mask = 1 << irq;
+
+        clrbits32(io_base + HW_BROADWAY_IMR, mask);
+        out_be32(io_base + HW_BROADWAY_ICR, mask);
+}
+
+static void hlwd_pic_ack(unsigned int virq)
+{
+        int irq = virq_to_hw(virq);
+        void __iomem *io_base = get_irq_chip_data(virq);
+
+        out_be32(io_base + HW_BROADWAY_ICR, 1 << irq);
+}
+
+static void hlwd_pic_mask(unsigned int virq)
+{
+        int irq = virq_to_hw(virq);
+        void __iomem *io_base = get_irq_chip_data(virq);
+
+        clrbits32(io_base + HW_BROADWAY_IMR, 1 << irq);
+}
+
+static void hlwd_pic_unmask(unsigned int virq)
+{
+        int irq = virq_to_hw(virq);
+        void __iomem *io_base = get_irq_chip_data(virq);
+
+        setbits32(io_base + HW_BROADWAY_IMR, 1 << irq);
+}
+
+
+static struct irq_chip hlwd_pic = {
+        .name           = "hlwd-pic",
+        .ack            = hlwd_pic_ack,
+        .mask_ack       = hlwd_pic_mask_and_ack,
+        .mask           = hlwd_pic_mask,
+        .unmask         = hlwd_pic_unmask,
+};
+
+/*
+ * IRQ host hooks.
+ *
+ */
+
+static struct irq_host *hlwd_irq_host;
+
+static int hlwd_pic_map(struct irq_host *h, unsigned int virq,
+                           irq_hw_number_t hwirq)
+{
+        set_irq_chip_data(virq, h->host_data);
+        irq_to_desc(virq)->status |= IRQ_LEVEL;
+        set_irq_chip_and_handler(virq, &hlwd_pic, handle_level_irq);
+        return 0;
+}
+
+static void hlwd_pic_unmap(struct irq_host *h, unsigned int irq)
+{
+        set_irq_chip_data(irq, NULL);
+        set_irq_chip(irq, NULL);
+}
+
+static struct irq_host_ops hlwd_irq_host_ops = {
+        .map = hlwd_pic_map,
+        .unmap = hlwd_pic_unmap,
+};
+
+static unsigned int __hlwd_pic_get_irq(struct irq_host *h)
+{
+        void __iomem *io_base = h->host_data;
+        int irq;
+        u32 irq_status;
+
+        irq_status = in_be32(io_base + HW_BROADWAY_ICR) &
+                     in_be32(io_base + HW_BROADWAY_IMR);
+        if (irq_status == 0)
+                return NO_IRQ;  /* no more IRQs pending */
+
+        irq = __ffs(irq_status);
+        return irq_linear_revmap(h, irq);
+}
+
+static void hlwd_pic_irq_cascade(unsigned int cascade_virq,
+                                      struct irq_desc *desc)
+{
+        struct irq_host *irq_host = get_irq_data(cascade_virq);
+        unsigned int virq;
+
+        raw_spin_lock(&desc->lock);
+        desc->chip->mask(cascade_virq); /* IRQ_LEVEL */
+        raw_spin_unlock(&desc->lock);
+
+        virq = __hlwd_pic_get_irq(irq_host);
+        if (virq != NO_IRQ)
+                generic_handle_irq(virq);
+        else
+                pr_err("spurious interrupt!\n");
+
+        raw_spin_lock(&desc->lock);
+        desc->chip->ack(cascade_virq); /* IRQ_LEVEL */
+        if (!(desc->status & IRQ_DISABLED) && desc->chip->unmask)
+                desc->chip->unmask(cascade_virq);
+        raw_spin_unlock(&desc->lock);
+}
+
+/*
+ * Platform hooks.
+ *
+ */
+
+static void __hlwd_quiesce(void __iomem *io_base)
+{
+        /* mask and ack all IRQs */
+        out_be32(io_base + HW_BROADWAY_IMR, 0);
+        out_be32(io_base + HW_BROADWAY_ICR, 0xffffffff);
+}
+
+struct irq_host *hlwd_pic_init(struct device_node *np)
+{
+        struct irq_host *irq_host;
+        struct resource res;
+        void __iomem *io_base;
+        int retval;
+
+        retval = of_address_to_resource(np, 0, &res);
+        if (retval) {
+                pr_err("no io memory range found\n");
+                return NULL;
+        }
+        io_base = ioremap(res.start, resource_size(&res));
+        if (!io_base) {
+                pr_err("ioremap failed\n");
+                return NULL;
+        }
+
+        pr_info("controller at 0x%08x mapped to 0x%p\n", res.start, io_base);
+
+        __hlwd_quiesce(io_base);
+
+        irq_host = irq_alloc_host(np, IRQ_HOST_MAP_LINEAR, HLWD_NR_IRQS,
+                                  &hlwd_irq_host_ops, -1);
+        if (!irq_host) {
+                pr_err("failed to allocate irq_host\n");
+                return NULL;
+        }
+        irq_host->host_data = io_base;
+
+        return irq_host;
+}
+
+unsigned int hlwd_pic_get_irq(void)
+{
+        return __hlwd_pic_get_irq(hlwd_irq_host);
+}
+
+/*
+ * Probe function.
+ *
+ */
+
+void hlwd_pic_probe(void)
+{
+        struct irq_host *host;
+        struct device_node *np;
+        const u32 *interrupts;
+        int cascade_virq;
+
+        for_each_compatible_node(np, NULL, "nintendo,hollywood-pic") {
+                interrupts = of_get_property(np, "interrupts", NULL);
+                if (interrupts) {
+                        host = hlwd_pic_init(np);
+                        BUG_ON(!host);
+                        cascade_virq = irq_of_parse_and_map(np, 0);
+                        set_irq_data(cascade_virq, host);
+                        set_irq_chained_handler(cascade_virq,
+                                                hlwd_pic_irq_cascade);
+                        hlwd_irq_host = host;
+                        break;
+                }
+        }
+}
+
+/**
+ * hlwd_quiesce() - quiesce hollywood irq controller
+ *
+ * Mask and ack all interrupt sources.
+ *
+ */
+void hlwd_quiesce(void)
+{
+        void __iomem *io_base = hlwd_irq_host->host_data;
+
+        __hlwd_quiesce(io_base);
+}
+
diff --git a/arch/powerpc/platforms/embedded6xx/hlwd-pic.h b/arch/powerpc/platforms/embedded6xx/hlwd-pic.h
new file mode 100644
index 000000000000..d2e5a092761e
--- /dev/null
+++ b/arch/powerpc/platforms/embedded6xx/hlwd-pic.h
@@ -0,0 +1,22 @@
+/*
+ * arch/powerpc/platforms/embedded6xx/hlwd-pic.h
+ *
+ * Nintendo Wii "Hollywood" interrupt controller support.
+ * Copyright (C) 2009 The GameCube Linux Team
+ * Copyright (C) 2009 Albert Herranz
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ */
+
+#ifndef __HLWD_PIC_H
+#define __HLWD_PIC_H
+
+extern unsigned int hlwd_pic_get_irq(void);
+extern void hlwd_pic_probe(void);
+extern void hlwd_quiesce(void);
+
+#endif
diff --git a/arch/powerpc/platforms/embedded6xx/usbgecko_udbg.c b/arch/powerpc/platforms/embedded6xx/usbgecko_udbg.c
new file mode 100644
index 000000000000..20a8ed91962e
--- /dev/null
+++ b/arch/powerpc/platforms/embedded6xx/usbgecko_udbg.c
@@ -0,0 +1,328 @@
+/*
+ * arch/powerpc/platforms/embedded6xx/usbgecko_udbg.c
+ *
+ * udbg serial input/output routines for the USB Gecko adapter.
+ * Copyright (C) 2008-2009 The GameCube Linux Team
+ * Copyright (C) 2008,2009 Albert Herranz
+ *
+ * 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 <mm/mmu_decl.h>
+
+#include <asm/io.h>
+#include <asm/prom.h>
+#include <asm/udbg.h>
+#include <asm/fixmap.h>
+
+#include "usbgecko_udbg.h"
+
+
+#define EXI_CLK_32MHZ           5
+
+#define EXI_CSR                 0x00
+#define   EXI_CSR_CLKMASK       (0x7<<4)
+#define     EXI_CSR_CLK_32MHZ   (EXI_CLK_32MHZ<<4)
+#define   EXI_CSR_CSMASK        (0x7<<7)
+#define     EXI_CSR_CS_0        (0x1<<7)  /* Chip Select 001 */
+
+#define EXI_CR                  0x0c
+#define   EXI_CR_TSTART         (1<<0)
+#define   EXI_CR_WRITE          (1<<2)
+#define   EXI_CR_READ_WRITE     (2<<2)
+#define   EXI_CR_TLEN(len)      (((len)-1)<<4)
+
+#define EXI_DATA                0x10
+
+#define UG_READ_ATTEMPTS        100
+#define UG_WRITE_ATTEMPTS       100
+
+
+static void __iomem *ug_io_base;
+
+/*
+ * Performs one input/output transaction between the exi host and the usbgecko.
+ */
+static u32 ug_io_transaction(u32 in)
+{
+        u32 __iomem *csr_reg = ug_io_base + EXI_CSR;
+        u32 __iomem *data_reg = ug_io_base + EXI_DATA;
+        u32 __iomem *cr_reg = ug_io_base + EXI_CR;
+        u32 csr, data, cr;
+
+        /* select */
+        csr = EXI_CSR_CLK_32MHZ | EXI_CSR_CS_0;
+        out_be32(csr_reg, csr);
+
+        /* read/write */
+        data = in;
+        out_be32(data_reg, data);
+        cr = EXI_CR_TLEN(2) | EXI_CR_READ_WRITE | EXI_CR_TSTART;
+        out_be32(cr_reg, cr);
+
+        while (in_be32(cr_reg) & EXI_CR_TSTART)
+                barrier();
+
+        /* deselect */
+        out_be32(csr_reg, 0);
+
+        /* result */
+        data = in_be32(data_reg);
+
+        return data;
+}
+
+/*
+ * Returns true if an usbgecko adapter is found.
+ */
+static int ug_is_adapter_present(void)
+{
+        if (!ug_io_base)
+                return 0;
+
+        return ug_io_transaction(0x90000000) == 0x04700000;
+}
+
+/*
+ * Returns true if the TX fifo is ready for transmission.
+ */
+static int ug_is_txfifo_ready(void)
+{
+        return ug_io_transaction(0xc0000000) & 0x04000000;
+}
+
+/*
+ * Tries to transmit a character.
+ * If the TX fifo is not ready the result is undefined.
+ */
+static void ug_raw_putc(char ch)
+{
+        ug_io_transaction(0xb0000000 | (ch << 20));
+}
+
+/*
+ * Transmits a character.
+ * It silently fails if the TX fifo is not ready after a number of retries.
+ */
+static void ug_putc(char ch)
+{
+        int count = UG_WRITE_ATTEMPTS;
+
+        if (!ug_io_base)
+                return;
+
+        if (ch == '\n')
+                ug_putc('\r');
+
+        while (!ug_is_txfifo_ready() && count--)
+                barrier();
+        if (count >= 0)
+                ug_raw_putc(ch);
+}
+
+/*
+ * Returns true if the RX fifo is ready for transmission.
+ */
+static int ug_is_rxfifo_ready(void)
+{
+        return ug_io_transaction(0xd0000000) & 0x04000000;
+}
+
+/*
+ * Tries to receive a character.
+ * If a character is unavailable the function returns -1.
+ */
+static int ug_raw_getc(void)
+{
+        u32 data = ug_io_transaction(0xa0000000);
+        if (data & 0x08000000)
+                return (data >> 16) & 0xff;
+        else
+                return -1;
+}
+
+/*
+ * Receives a character.
+ * It fails if the RX fifo is not ready after a number of retries.
+ */
+static int ug_getc(void)
+{
+        int count = UG_READ_ATTEMPTS;
+
+        if (!ug_io_base)
+                return -1;
+
+        while (!ug_is_rxfifo_ready() && count--)
+                barrier();
+        return ug_raw_getc();
+}
+
+/*
+ * udbg functions.
+ *
+ */
+
+/*
+ * Transmits a character.
+ */
+void ug_udbg_putc(char ch)
+{
+        ug_putc(ch);
+}
+
+/*
+ * Receives a character. Waits until a character is available.
+ */
+static int ug_udbg_getc(void)
+{
+        int ch;
+
+        while ((ch = ug_getc()) == -1)
+                barrier();
+        return ch;
+}
+
+/*
+ * Receives a character. If a character is not available, returns -1.
+ */
+static int ug_udbg_getc_poll(void)
+{
+        if (!ug_is_rxfifo_ready())
+                return -1;
+        return ug_getc();
+}
+
+/*
+ * Retrieves and prepares the virtual address needed to access the hardware.
+ */
+static void __iomem *ug_udbg_setup_exi_io_base(struct device_node *np)
+{
+        void __iomem *exi_io_base = NULL;
+        phys_addr_t paddr;
+        const unsigned int *reg;
+
+        reg = of_get_property(np, "reg", NULL);
+        if (reg) {
+                paddr = of_translate_address(np, reg);
+                if (paddr)
+                        exi_io_base = ioremap(paddr, reg[1]);
+        }
+        return exi_io_base;
+}
+
+/*
+ * Checks if a USB Gecko adapter is inserted in any memory card slot.
+ */
+static void __iomem *ug_udbg_probe(void __iomem *exi_io_base)
+{
+        int i;
+
+        /* look for a usbgecko on memcard slots A and B */
+        for (i = 0; i < 2; i++) {
+                ug_io_base = exi_io_base + 0x14 * i;
+                if (ug_is_adapter_present())
+                        break;
+        }
+        if (i == 2)
+                ug_io_base = NULL;
+        return ug_io_base;
+
+}
+
+/*
+ * USB Gecko udbg support initialization.
+ */
+void __init ug_udbg_init(void)
+{
+        struct device_node *np;
+        void __iomem *exi_io_base;
+
+        if (ug_io_base)
+                udbg_printf("%s: early -> final\n", __func__);
+
+        np = of_find_compatible_node(NULL, NULL, "nintendo,flipper-exi");
+        if (!np) {
+                udbg_printf("%s: EXI node not found\n", __func__);
+                goto done;
+        }
+
+        exi_io_base = ug_udbg_setup_exi_io_base(np);
+        if (!exi_io_base) {
+                udbg_printf("%s: failed to setup EXI io base\n", __func__);
+                goto done;
+        }
+
+        if (!ug_udbg_probe(exi_io_base)) {
+                udbg_printf("usbgecko_udbg: not found\n");
+                iounmap(exi_io_base);
+        } else {
+                udbg_putc = ug_udbg_putc;
+                udbg_getc = ug_udbg_getc;
+                udbg_getc_poll = ug_udbg_getc_poll;
+                udbg_printf("usbgecko_udbg: ready\n");
+        }
+
+done:
+        if (np)
+                of_node_put(np);
+        return;
+}
+
+#ifdef CONFIG_PPC_EARLY_DEBUG_USBGECKO
+
+static phys_addr_t __init ug_early_grab_io_addr(void)
+{
+#if defined(CONFIG_GAMECUBE)
+        return 0x0c000000;
+#elif defined(CONFIG_WII)
+        return 0x0d000000;
+#else
+#error Invalid platform for USB Gecko based early debugging.
+#endif
+}
+
+/*
+ * USB Gecko early debug support initialization for udbg.
+ */
+void __init udbg_init_usbgecko(void)
+{
+        void __iomem *early_debug_area;
+        void __iomem *exi_io_base;
+
+        /*
+         * At this point we have a BAT already setup that enables I/O
+         * to the EXI hardware.
+         *
+         * The BAT uses a virtual address range reserved at the fixmap.
+         * This must match the virtual address configured in
+         * head_32.S:setup_usbgecko_bat().
+         */
+        early_debug_area = (void __iomem *)__fix_to_virt(FIX_EARLY_DEBUG_BASE);
+        exi_io_base = early_debug_area + 0x00006800;
+
+        /* try to detect a USB Gecko */
+        if (!ug_udbg_probe(exi_io_base))
+                return;
+
+        /* we found a USB Gecko, load udbg hooks */
+        udbg_putc = ug_udbg_putc;
+        udbg_getc = ug_udbg_getc;
+        udbg_getc_poll = ug_udbg_getc_poll;
+
+        /*
+         * Prepare again the same BAT for MMU_init.
+         * This allows udbg I/O to continue working after the MMU is
+         * turned on for real.
+         * It is safe to continue using the same virtual address as it is
+         * a reserved fixmap area.
+         */
+        setbat(1, (unsigned long)early_debug_area,
+               ug_early_grab_io_addr(), 128*1024, PAGE_KERNEL_NCG);
+}
+
+#endif /* CONFIG_PPC_EARLY_DEBUG_USBGECKO */
+
diff --git a/arch/powerpc/platforms/embedded6xx/usbgecko_udbg.h b/arch/powerpc/platforms/embedded6xx/usbgecko_udbg.h
new file mode 100644
index 000000000000..bb6cde4ad764
--- /dev/null
+++ b/arch/powerpc/platforms/embedded6xx/usbgecko_udbg.h
@@ -0,0 +1,32 @@
+/*
+ * arch/powerpc/platforms/embedded6xx/usbgecko_udbg.h
+ *
+ * udbg serial input/output routines for the USB Gecko adapter.
+ * Copyright (C) 2008-2009 The GameCube Linux Team
+ * Copyright (C) 2008,2009 Albert Herranz
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ */
+
+#ifndef __USBGECKO_UDBG_H
+#define __USBGECKO_UDBG_H
+
+#ifdef CONFIG_USBGECKO_UDBG
+
+extern void __init ug_udbg_init(void);
+
+#else
+
+static inline void __init ug_udbg_init(void)
+{
+}
+
+#endif /* CONFIG_USBGECKO_UDBG */
+
+void __init udbg_init_usbgecko(void);
+
+#endif /* __USBGECKO_UDBG_H */
diff --git a/arch/powerpc/platforms/embedded6xx/wii.c b/arch/powerpc/platforms/embedded6xx/wii.c
new file mode 100644
index 000000000000..57e5b608fa1a
--- /dev/null
+++ b/arch/powerpc/platforms/embedded6xx/wii.c
@@ -0,0 +1,268 @@
+/*
+ * arch/powerpc/platforms/embedded6xx/wii.c
+ *
+ * Nintendo Wii board-specific support
+ * Copyright (C) 2008-2009 The GameCube Linux Team
+ * Copyright (C) 2008,2009 Albert Herranz
+ *
+ * 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.
+ *
+ */
+#define DRV_MODULE_NAME "wii"
+#define pr_fmt(fmt) DRV_MODULE_NAME ": " fmt
+
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/irq.h>
+#include <linux/seq_file.h>
+#include <linux/kexec.h>
+#include <linux/of_platform.h>
+#include <linux/lmb.h>
+#include <mm/mmu_decl.h>
+
+#include <asm/io.h>
+#include <asm/machdep.h>
+#include <asm/prom.h>
+#include <asm/time.h>
+#include <asm/udbg.h>
+
+#include "flipper-pic.h"
+#include "hlwd-pic.h"
+#include "usbgecko_udbg.h"
+
+/* control block */
+#define HW_CTRL_COMPATIBLE      "nintendo,hollywood-control"
+
+#define HW_CTRL_RESETS          0x94
+#define HW_CTRL_RESETS_SYS      (1<<0)
+
+/* gpio */
+#define HW_GPIO_COMPATIBLE      "nintendo,hollywood-gpio"
+
+#define HW_GPIO_BASE(idx)       (idx * 0x20)
+#define HW_GPIO_OUT(idx)        (HW_GPIO_BASE(idx) + 0)
+#define HW_GPIO_DIR(idx)        (HW_GPIO_BASE(idx) + 4)
+
+#define HW_GPIO_SHUTDOWN        (1<<1)
+#define HW_GPIO_SLOT_LED        (1<<5)
+#define HW_GPIO_SENSOR_BAR      (1<<8)
+
+
+static void __iomem *hw_ctrl;
+static void __iomem *hw_gpio;
+
+unsigned long wii_hole_start;
+unsigned long wii_hole_size;
+
+
+static int __init page_aligned(unsigned long x)
+{
+        return !(x & (PAGE_SIZE-1));
+}
+
+void __init wii_memory_fixups(void)
+{
+        struct lmb_property *p = lmb.memory.region;
+
+        /*
+         * This is part of a workaround to allow the use of two
+         * discontiguous RAM ranges on the Wii, even if this is
+         * currently unsupported on 32-bit PowerPC Linux.
+         *
+         * We coealesce the two memory ranges of the Wii into a
+         * single range, then create a reservation for the "hole"
+         * between both ranges.
+         */
+
+        BUG_ON(lmb.memory.cnt != 2);
+        BUG_ON(!page_aligned(p[0].base) || !page_aligned(p[1].base));
+
+        p[0].size = _ALIGN_DOWN(p[0].size, PAGE_SIZE);
+        p[1].size = _ALIGN_DOWN(p[1].size, PAGE_SIZE);
+
+        wii_hole_start = p[0].base + p[0].size;
+        wii_hole_size = p[1].base - wii_hole_start;
+
+        pr_info("MEM1: <%08llx %08llx>\n", p[0].base, p[0].size);
+        pr_info("HOLE: <%08lx %08lx>\n", wii_hole_start, wii_hole_size);
+        pr_info("MEM2: <%08llx %08llx>\n", p[1].base, p[1].size);
+
+        p[0].size += wii_hole_size + p[1].size;
+
+        lmb.memory.cnt = 1;
+        lmb_analyze();
+
+        /* reserve the hole */
+        lmb_reserve(wii_hole_start, wii_hole_size);
+
+        /* allow ioremapping the address space in the hole */
+        __allow_ioremap_reserved = 1;
+}
+
+unsigned long __init wii_mmu_mapin_mem2(unsigned long top)
+{
+        unsigned long delta, size, bl;
+        unsigned long max_size = (256<<20);
+
+        /* MEM2 64MB@0x10000000 */
+        delta = wii_hole_start + wii_hole_size;
+        size = top - delta;
+        for (bl = 128<<10; bl < max_size; bl <<= 1) {
+                if (bl * 2 > size)
+                        break;
+        }
+        setbat(4, PAGE_OFFSET+delta, delta, bl, PAGE_KERNEL_X);
+        return delta + bl;
+}
+
+static void wii_spin(void)
+{
+        local_irq_disable();
+        for (;;)
+                cpu_relax();
+}
+
+static void __iomem *wii_ioremap_hw_regs(char *name, char *compatible)
+{
+        void __iomem *hw_regs = NULL;
+        struct device_node *np;
+        struct resource res;
+        int error = -ENODEV;
+
+        np = of_find_compatible_node(NULL, NULL, compatible);
+        if (!np) {
+                pr_err("no compatible node found for %s\n", compatible);
+                goto out;
+        }
+        error = of_address_to_resource(np, 0, &res);
+        if (error) {
+                pr_err("no valid reg found for %s\n", np->name);
+                goto out_put;
+        }
+
+        hw_regs = ioremap(res.start, resource_size(&res));
+        if (hw_regs) {
+                pr_info("%s at 0x%08x mapped to 0x%p\n", name,
+                        res.start, hw_regs);
+        }
+
+out_put:
+        of_node_put(np);
+out:
+        return hw_regs;
+}
+
+static void __init wii_setup_arch(void)
+{
+        hw_ctrl = wii_ioremap_hw_regs("hw_ctrl", HW_CTRL_COMPATIBLE);
+        hw_gpio = wii_ioremap_hw_regs("hw_gpio", HW_GPIO_COMPATIBLE);
+        if (hw_gpio) {
+                /* turn off the front blue led and IR light */
+                clrbits32(hw_gpio + HW_GPIO_OUT(0),
+                          HW_GPIO_SLOT_LED | HW_GPIO_SENSOR_BAR);
+        }
+}
+
+static void wii_restart(char *cmd)
+{
+        local_irq_disable();
+
+        if (hw_ctrl) {
+                /* clear the system reset pin to cause a reset */
+                clrbits32(hw_ctrl + HW_CTRL_RESETS, HW_CTRL_RESETS_SYS);
+        }
+        wii_spin();
+}
+
+static void wii_power_off(void)
+{
+        local_irq_disable();
+
+        if (hw_gpio) {
+                /* make sure that the poweroff GPIO is configured as output */
+                setbits32(hw_gpio + HW_GPIO_DIR(1), HW_GPIO_SHUTDOWN);
+
+                /* drive the poweroff GPIO high */
+                setbits32(hw_gpio + HW_GPIO_OUT(1), HW_GPIO_SHUTDOWN);
+        }
+        wii_spin();
+}
+
+static void wii_halt(void)
+{
+        if (ppc_md.restart)
+                ppc_md.restart(NULL);
+        wii_spin();
+}
+
+static void __init wii_init_early(void)
+{
+        ug_udbg_init();
+}
+
+static void __init wii_pic_probe(void)
+{
+        flipper_pic_probe();
+        hlwd_pic_probe();
+}
+
+static int __init wii_probe(void)
+{
+        unsigned long dt_root;
+
+        dt_root = of_get_flat_dt_root();
+        if (!of_flat_dt_is_compatible(dt_root, "nintendo,wii"))
+                return 0;
+
+        return 1;
+}
+
+static void wii_shutdown(void)
+{
+        hlwd_quiesce();
+        flipper_quiesce();
+}
+
+#ifdef CONFIG_KEXEC
+static int wii_machine_kexec_prepare(struct kimage *image)
+{
+        return 0;
+}
+#endif /* CONFIG_KEXEC */
+
+define_machine(wii) {
+        .name                   = "wii",
+        .probe                  = wii_probe,
+        .init_early             = wii_init_early,
+        .setup_arch             = wii_setup_arch,
+        .restart                = wii_restart,
+        .power_off              = wii_power_off,
+        .halt                   = wii_halt,
+        .init_IRQ               = wii_pic_probe,
+        .get_irq                = flipper_pic_get_irq,
+        .calibrate_decr         = generic_calibrate_decr,
+        .progress               = udbg_progress,
+        .machine_shutdown       = wii_shutdown,
+#ifdef CONFIG_KEXEC
+        .machine_kexec_prepare  = wii_machine_kexec_prepare,
+#endif
+};
+
+static struct of_device_id wii_of_bus[] = {
+        { .compatible = "nintendo,hollywood", },
+        { },
+};
+
+static int __init wii_device_probe(void)
+{
+        if (!machine_is(wii))
+                return 0;
+
+        of_platform_bus_probe(NULL, wii_of_bus, NULL);
+        return 0;
+}
+device_initcall(wii_device_probe);
+
diff --git a/arch/powerpc/platforms/iseries/htab.c b/arch/powerpc/platforms/iseries/htab.c
index f99c6c4b6985..3ae66ab9d5e7 100644
--- a/arch/powerpc/platforms/iseries/htab.c
+++ b/arch/powerpc/platforms/iseries/htab.c
@@ -19,8 +19,7 @@
 
 #include "call_hpt.h"
 
-static spinlock_t iSeries_hlocks[64] __cacheline_aligned_in_smp =
-        { [0 ... 63] = SPIN_LOCK_UNLOCKED};
+static spinlock_t iSeries_hlocks[64] __cacheline_aligned_in_smp;
 
 /*
  * Very primitive algorithm for picking up a lock
@@ -245,6 +244,11 @@ static void iSeries_hpte_invalidate(unsigned long slot, unsigned long va,
 
 void __init hpte_init_iSeries(void)
 {
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(iSeries_hlocks); i++)
+                spin_lock_init(&iSeries_hlocks[i]);
+
         ppc_md.hpte_invalidate  = iSeries_hpte_invalidate;
         ppc_md.hpte_updatepp    = iSeries_hpte_updatepp;
         ppc_md.hpte_updateboltedpp = iSeries_hpte_updateboltedpp;
diff --git a/arch/powerpc/platforms/iseries/irq.c b/arch/powerpc/platforms/iseries/irq.c
index 94f444758836..86c4b29eea89 100644
--- a/arch/powerpc/platforms/iseries/irq.c
+++ b/arch/powerpc/platforms/iseries/irq.c
@@ -214,12 +214,12 @@ void __init iSeries_activate_IRQs()
         unsigned long flags;
 
         for_each_irq (irq) {
-                struct irq_desc *desc = get_irq_desc(irq);
+                struct irq_desc *desc = irq_to_desc(irq);
 
                 if (desc && desc->chip && desc->chip->startup) {
-                        spin_lock_irqsave(&desc->lock, flags);
+                        raw_spin_lock_irqsave(&desc->lock, flags);
                         desc->chip->startup(irq);
-                        spin_unlock_irqrestore(&desc->lock, flags);
+                        raw_spin_unlock_irqrestore(&desc->lock, flags);
                 }
         }
 }
@@ -273,7 +273,7 @@ static void iseries_end_IRQ(unsigned int irq)
 }
 
 static struct irq_chip iseries_pic = {
-        .typename       = "iSeries irq controller",
+        .name   = "iSeries irq controller",
         .startup        = iseries_startup_IRQ,
         .shutdown       = iseries_shutdown_IRQ,
         .unmask         = iseries_enable_IRQ,
diff --git a/arch/powerpc/platforms/iseries/mf.c b/arch/powerpc/platforms/iseries/mf.c
index 0d9343df35bc..6617915bcb1a 100644
--- a/arch/powerpc/platforms/iseries/mf.c
+++ b/arch/powerpc/platforms/iseries/mf.c
@@ -855,59 +855,58 @@ static int mf_get_boot_rtc(struct rtc_time *tm)
 }
 
 #ifdef CONFIG_PROC_FS
-
-static int proc_mf_dump_cmdline(char *page, char **start, off_t off,
-                int count, int *eof, void *data)
+static int mf_cmdline_proc_show(struct seq_file *m, void *v)
 {
-        int len;
-        char *p;
+        char *page, *p;
         struct vsp_cmd_data vsp_cmd;
         int rc;
         dma_addr_t dma_addr;
 
         /* The HV appears to return no more than 256 bytes of command line */
-        if (off >= 256)
-                return 0;
-        if ((off + count) > 256)
-                count = 256 - off;
+        page = kmalloc(256, GFP_KERNEL);
+        if (!page)
+                return -ENOMEM;
 
-        dma_addr = iseries_hv_map(page, off + count, DMA_FROM_DEVICE);
-        if (dma_addr == DMA_ERROR_CODE)
+        dma_addr = iseries_hv_map(page, 256, DMA_FROM_DEVICE);
+        if (dma_addr == DMA_ERROR_CODE) {
+                kfree(page);
                 return -ENOMEM;
-        memset(page, 0, off + count);
+        }
+        memset(page, 0, 256);
         memset(&vsp_cmd, 0, sizeof(vsp_cmd));
         vsp_cmd.cmd = 33;
         vsp_cmd.sub_data.kern.token = dma_addr;
         vsp_cmd.sub_data.kern.address_type = HvLpDma_AddressType_TceIndex;
-        vsp_cmd.sub_data.kern.side = (u64)data;
-        vsp_cmd.sub_data.kern.length = off + count;
+        vsp_cmd.sub_data.kern.side = (u64)m->private;
+        vsp_cmd.sub_data.kern.length = 256;
         mb();
         rc = signal_vsp_instruction(&vsp_cmd);
-        iseries_hv_unmap(dma_addr, off + count, DMA_FROM_DEVICE);
-        if (rc)
+        iseries_hv_unmap(dma_addr, 256, DMA_FROM_DEVICE);
+        if (rc) {
+                kfree(page);
                 return rc;
-        if (vsp_cmd.result_code != 0)
+        }
+        if (vsp_cmd.result_code != 0) {
+                kfree(page);
                 return -ENOMEM;
+        }
         p = page;
-        len = 0;
-        while (len < (off + count)) {
-                if ((*p == '\0') || (*p == '\n')) {
-                        if (*p == '\0')
-                                *p = '\n';
-                        p++;
-                        len++;
-                        *eof = 1;
+        while (p - page < 256) {
+                if (*p == '\0' || *p == '\n') {
+                        *p = '\n';
                         break;
                 }
                 p++;
-                len++;
-        }
 
-        if (len < off) {
-                *eof = 1;
-                len = 0;
         }
-        return len;
+        seq_write(m, page, p - page);
+        kfree(page);
+        return 0;
+}
+
+static int mf_cmdline_proc_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, mf_cmdline_proc_show, PDE(inode)->data);
 }
 
 #if 0
@@ -962,10 +961,8 @@ static int proc_mf_dump_vmlinux(char *page, char **start, off_t off,
 }
 #endif
 
-static int proc_mf_dump_side(char *page, char **start, off_t off,
-                int count, int *eof, void *data)
+static int mf_side_proc_show(struct seq_file *m, void *v)
 {
-        int len;
         char mf_current_side = ' ';
         struct vsp_cmd_data vsp_cmd;
 
@@ -989,21 +986,17 @@ static int proc_mf_dump_side(char *page, char **start, off_t off,
                 }
         }
 
-        len = sprintf(page, "%c\n", mf_current_side);
+        seq_printf(m, "%c\n", mf_current_side);
+        return 0;
+}
 
-        if (len <= (off + count))
-                *eof = 1;
-        *start = page + off;
-        len -= off;
-        if (len > count)
-                len = count;
-        if (len < 0)
-                len = 0;
-        return len;
+static int mf_side_proc_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, mf_side_proc_show, NULL);
 }
 
-static int proc_mf_change_side(struct file *file, const char __user *buffer,
-                unsigned long count, void *data)
+static ssize_t mf_side_proc_write(struct file *file, const char __user *buffer,
+                                  size_t count, loff_t *pos)
 {
         char side;
         u64 newSide;
@@ -1041,6 +1034,15 @@ static int proc_mf_change_side(struct file *file, const char __user *buffer,
         return count;
 }
 
+static const struct file_operations mf_side_proc_fops = {
+        .owner          = THIS_MODULE,
+        .open           = mf_side_proc_open,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+        .release        = single_release,
+        .write          = mf_side_proc_write,
+};
+
 #if 0
 static void mf_getSrcHistory(char *buffer, int size)
 {
@@ -1087,8 +1089,7 @@ static void mf_getSrcHistory(char *buffer, int size)
 }
 #endif
 
-static int proc_mf_dump_src(char *page, char **start, off_t off,
-                int count, int *eof, void *data)
+static int mf_src_proc_show(struct seq_file *m, void *v)
 {
 #if 0
         int len;
@@ -1109,8 +1110,13 @@ static int proc_mf_dump_src(char *page, char **start, off_t off,
 #endif
 }
 
-static int proc_mf_change_src(struct file *file, const char __user *buffer,
-                unsigned long count, void *data)
+static int mf_src_proc_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, mf_src_proc_show, NULL);
+}
+
+static ssize_t mf_src_proc_write(struct file *file, const char __user *buffer,
+                                 size_t count, loff_t *pos)
 {
         char stkbuf[10];
 
@@ -1135,9 +1141,19 @@ static int proc_mf_change_src(struct file *file, const char __user *buffer,
         return count;
 }
 
-static int proc_mf_change_cmdline(struct file *file, const char __user *buffer,
-                unsigned long count, void *data)
+static const struct file_operations mf_src_proc_fops = {
+        .owner          = THIS_MODULE,
+        .open           = mf_src_proc_open,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+        .release        = single_release,
+        .write          = mf_src_proc_write,
+};
+
+static ssize_t mf_cmdline_proc_write(struct file *file, const char __user *buffer,
+                                     size_t count, loff_t *pos)
 {
+        void *data = PDE(file->f_path.dentry->d_inode)->data;
         struct vsp_cmd_data vsp_cmd;
         dma_addr_t dma_addr;
         char *page;
@@ -1172,6 +1188,15 @@ out:
         return ret;
 }
 
+static const struct file_operations mf_cmdline_proc_fops = {
+        .owner          = THIS_MODULE,
+        .open           = mf_cmdline_proc_open,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+        .release        = single_release,
+        .write          = mf_cmdline_proc_write,
+};
+
 static ssize_t proc_mf_change_vmlinux(struct file *file,
                                       const char __user *buf,
                                       size_t count, loff_t *ppos)
@@ -1246,12 +1271,10 @@ static int __init mf_proc_init(void)
                 if (!mf)
                         return 1;
 
-                ent = create_proc_entry("cmdline", S_IFREG|S_IRUSR|S_IWUSR, mf);
+                ent = proc_create_data("cmdline", S_IRUSR|S_IWUSR, mf,
+                                       &mf_cmdline_proc_fops, (void *)(long)i);
                 if (!ent)
                         return 1;
-                ent->data = (void *)(long)i;
-                ent->read_proc = proc_mf_dump_cmdline;
-                ent->write_proc = proc_mf_change_cmdline;
 
                 if (i == 3)     /* no vmlinux entry for 'D' */
                         continue;
@@ -1263,19 +1286,15 @@ static int __init mf_proc_init(void)
                         return 1;
         }
 
-        ent = create_proc_entry("side", S_IFREG|S_IRUSR|S_IWUSR, mf_proc_root);
+        ent = proc_create("side", S_IFREG|S_IRUSR|S_IWUSR, mf_proc_root,
+                          &mf_side_proc_fops);
         if (!ent)
                 return 1;
-        ent->data = (void *)0;
-        ent->read_proc = proc_mf_dump_side;
-        ent->write_proc = proc_mf_change_side;
 
-        ent = create_proc_entry("src", S_IFREG|S_IRUSR|S_IWUSR, mf_proc_root);
+        ent = proc_create("src", S_IFREG|S_IRUSR|S_IWUSR, mf_proc_root,
+                          &mf_src_proc_fops);
         if (!ent)
                 return 1;
-        ent->data = (void *)0;
-        ent->read_proc = proc_mf_dump_src;
-        ent->write_proc = proc_mf_change_src;
 
         return 0;
 }
diff --git a/arch/powerpc/platforms/iseries/vio.c b/arch/powerpc/platforms/iseries/vio.c
index 657b72f68493..2aa8b5631beb 100644
--- a/arch/powerpc/platforms/iseries/vio.c
+++ b/arch/powerpc/platforms/iseries/vio.c
@@ -474,6 +474,8 @@ static void __init get_viotape_info(struct device_node *vio_root)
         struct vio_waitevent we;
         int ret;
 
+        init_completion(&we.com);
+
         ret = viopath_open(viopath_hostLp, viomajorsubtype_tape, 2);
         if (ret) {
                 printk(KERN_WARNING "get_viotape_info: "
diff --git a/arch/powerpc/platforms/iseries/viopath.c b/arch/powerpc/platforms/iseries/viopath.c
index 49ff4dc422b7..5aea94f30836 100644
--- a/arch/powerpc/platforms/iseries/viopath.c
+++ b/arch/powerpc/platforms/iseries/viopath.c
@@ -116,7 +116,7 @@ static int proc_viopath_show(struct seq_file *m, void *v)
         u16 vlanMap;
         dma_addr_t handle;
         HvLpEvent_Rc hvrc;
-        DECLARE_COMPLETION(done);
+        DECLARE_COMPLETION_ONSTACK(done);
         struct device_node *node;
         const char *sysid;
 
diff --git a/arch/powerpc/platforms/pasemi/setup.c b/arch/powerpc/platforms/pasemi/setup.c
index a4619347aa7e..242f8095c2df 100644
--- a/arch/powerpc/platforms/pasemi/setup.c
+++ b/arch/powerpc/platforms/pasemi/setup.c
@@ -71,7 +71,7 @@ static void pas_restart(char *cmd)
 }
 
 #ifdef CONFIG_SMP
-static raw_spinlock_t timebase_lock;
+static arch_spinlock_t timebase_lock;
 static unsigned long timebase;
 
 static void __devinit pas_give_timebase(void)
@@ -80,11 +80,11 @@ static void __devinit pas_give_timebase(void)
 
         local_irq_save(flags);
         hard_irq_disable();
-        __raw_spin_lock(&timebase_lock);
+        arch_spin_lock(&timebase_lock);
         mtspr(SPRN_TBCTL, TBCTL_FREEZE);
         isync();
         timebase = get_tb();
-        __raw_spin_unlock(&timebase_lock);
+        arch_spin_unlock(&timebase_lock);
 
         while (timebase)
                 barrier();
@@ -97,10 +97,10 @@ static void __devinit pas_take_timebase(void)
         while (!timebase)
                 smp_rmb();
 
-        __raw_spin_lock(&timebase_lock);
+        arch_spin_lock(&timebase_lock);
         set_tb(timebase >> 32, timebase & 0xffffffff);
         timebase = 0;
-        __raw_spin_unlock(&timebase_lock);
+        arch_spin_unlock(&timebase_lock);
 }
 
 struct smp_ops_t pas_smp_ops = {
diff --git a/arch/powerpc/platforms/powermac/bootx_init.c b/arch/powerpc/platforms/powermac/bootx_init.c
index cf660916ae0b..9dd789a7370d 100644
--- a/arch/powerpc/platforms/powermac/bootx_init.c
+++ b/arch/powerpc/platforms/powermac/bootx_init.c
@@ -12,7 +12,7 @@
 #include <linux/kernel.h>
 #include <linux/string.h>
 #include <linux/init.h>
-#include <linux/utsrelease.h>
+#include <generated/utsrelease.h>
 #include <asm/sections.h>
 #include <asm/prom.h>
 #include <asm/page.h>
diff --git a/arch/powerpc/platforms/powermac/low_i2c.c b/arch/powerpc/platforms/powermac/low_i2c.c
index 414ca9849f23..345e2da56767 100644
--- a/arch/powerpc/platforms/powermac/low_i2c.c
+++ b/arch/powerpc/platforms/powermac/low_i2c.c
@@ -42,6 +42,7 @@
 #include <linux/interrupt.h>
 #include <linux/timer.h>
 #include <linux/mutex.h>
+#include <linux/i2c.h>
 #include <asm/keylargo.h>
 #include <asm/uninorth.h>
 #include <asm/io.h>
@@ -80,7 +81,7 @@ struct pmac_i2c_bus
         struct device_node      *busnode;
         int                     type;
         int                     flags;
-        struct i2c_adapter      *adapter;
+        struct i2c_adapter      adapter;
         void                    *hostdata;
         int                     channel;        /* some hosts have multiple */
         int                     mode;           /* current mode */
@@ -1014,25 +1015,9 @@ int pmac_i2c_get_channel(struct pmac_i2c_bus *bus)
 EXPORT_SYMBOL_GPL(pmac_i2c_get_channel);
 
 
-void pmac_i2c_attach_adapter(struct pmac_i2c_bus *bus,
-                             struct i2c_adapter *adapter)
-{
-        WARN_ON(bus->adapter != NULL);
-        bus->adapter = adapter;
-}
-EXPORT_SYMBOL_GPL(pmac_i2c_attach_adapter);
-
-void pmac_i2c_detach_adapter(struct pmac_i2c_bus *bus,
-                             struct i2c_adapter *adapter)
-{
-        WARN_ON(bus->adapter != adapter);
-        bus->adapter = NULL;
-}
-EXPORT_SYMBOL_GPL(pmac_i2c_detach_adapter);
-
 struct i2c_adapter *pmac_i2c_get_adapter(struct pmac_i2c_bus *bus)
 {
-        return bus->adapter;
+        return &bus->adapter;
 }
 EXPORT_SYMBOL_GPL(pmac_i2c_get_adapter);
 
@@ -1041,7 +1026,7 @@ struct pmac_i2c_bus *pmac_i2c_adapter_to_bus(struct i2c_adapter *adapter)
         struct pmac_i2c_bus *bus;
 
         list_for_each_entry(bus, &pmac_i2c_busses, link)
-                if (bus->adapter == adapter)
+                if (&bus->adapter == adapter)
                         return bus;
         return NULL;
 }
@@ -1053,7 +1038,7 @@ int pmac_i2c_match_adapter(struct device_node *dev, struct i2c_adapter *adapter)
 
         if (bus == NULL)
                 return 0;
-        return (bus->adapter == adapter);
+        return (&bus->adapter == adapter);
 }
 EXPORT_SYMBOL_GPL(pmac_i2c_match_adapter);
 
diff --git a/arch/powerpc/platforms/powermac/pci.c b/arch/powerpc/platforms/powermac/pci.c
index e81403b245b5..ab2027cdf893 100644
--- a/arch/powerpc/platforms/powermac/pci.c
+++ b/arch/powerpc/platforms/powermac/pci.c
@@ -302,7 +302,7 @@ static void __init setup_chaos(struct pci_controller *hose,
  *  1 -> Skip the device but act as if the access was successfull
  *       (return 0xff's on reads, eventually, cache config space
  *       accesses in a later version)
- * -1 -> Hide the device (unsuccessful acess)
+ * -1 -> Hide the device (unsuccessful access)
  */
 static int u3_ht_skip_device(struct pci_controller *hose,
                              struct pci_bus *bus, unsigned int devfn)
diff --git a/arch/powerpc/platforms/powermac/pic.c b/arch/powerpc/platforms/powermac/pic.c
index d212006a5b3c..09e827296276 100644
--- a/arch/powerpc/platforms/powermac/pic.c
+++ b/arch/powerpc/platforms/powermac/pic.c
@@ -152,12 +152,12 @@ static unsigned int pmac_startup_irq(unsigned int virq)
         unsigned long bit = 1UL << (src & 0x1f);
         int i = src >> 5;
 
-        spin_lock_irqsave(&pmac_pic_lock, flags);
-        if ((irq_desc[virq].status & IRQ_LEVEL) == 0)
+        spin_lock_irqsave(&pmac_pic_lock, flags);
+        if ((irq_to_desc(virq)->status & IRQ_LEVEL) == 0)
                 out_le32(&pmac_irq_hw[i]->ack, bit);
         __set_bit(src, ppc_cached_irq_mask);
         __pmac_set_irq_mask(src, 0);
-        spin_unlock_irqrestore(&pmac_pic_lock, flags);
+        spin_unlock_irqrestore(&pmac_pic_lock, flags);
 
         return 0;
 }
@@ -195,7 +195,7 @@ static int pmac_retrigger(unsigned int virq)
 }
 
 static struct irq_chip pmac_pic = {
-        .typename       = " PMAC-PIC ",
+        .name           = " PMAC-PIC ",
         .startup        = pmac_startup_irq,
         .mask           = pmac_mask_irq,
         .ack            = pmac_ack_irq,
@@ -285,7 +285,7 @@ static int pmac_pic_host_match(struct irq_host *h, struct device_node *node)
 static int pmac_pic_host_map(struct irq_host *h, unsigned int virq,
                              irq_hw_number_t hw)
 {
-        struct irq_desc *desc = get_irq_desc(virq);
+        struct irq_desc *desc = irq_to_desc(virq);
         int level;
 
         if (hw >= max_irqs)
@@ -303,7 +303,7 @@ static int pmac_pic_host_map(struct irq_host *h, unsigned int virq,
 }
 
 static int pmac_pic_host_xlate(struct irq_host *h, struct device_node *ct,
-                               u32 *intspec, unsigned int intsize,
+                               const u32 *intspec, unsigned int intsize,
                                irq_hw_number_t *out_hwirq,
                                unsigned int *out_flags)
 
diff --git a/arch/powerpc/platforms/ps3/interrupt.c b/arch/powerpc/platforms/ps3/interrupt.c
index 8ec5ccf76b19..59d9712d7364 100644
--- a/arch/powerpc/platforms/ps3/interrupt.c
+++ b/arch/powerpc/platforms/ps3/interrupt.c
@@ -152,7 +152,7 @@ static void ps3_chip_eoi(unsigned int virq)
  */
 
 static struct irq_chip ps3_irq_chip = {
-        .typename = "ps3",
+        .name = "ps3",
         .mask = ps3_chip_mask,
         .unmask = ps3_chip_unmask,
         .eoi = ps3_chip_eoi,
diff --git a/arch/powerpc/platforms/ps3/mm.c b/arch/powerpc/platforms/ps3/mm.c
index 189a25b80735..e81b028a2a48 100644
--- a/arch/powerpc/platforms/ps3/mm.c
+++ b/arch/powerpc/platforms/ps3/mm.c
@@ -34,7 +34,7 @@
 #if defined(DEBUG)
 #define DBG udbg_printf
 #else
-#define DBG pr_debug
+#define DBG pr_devel
 #endif
 
 enum {
diff --git a/arch/powerpc/platforms/pseries/Kconfig b/arch/powerpc/platforms/pseries/Kconfig
index f0e6f28427bd..c667f0f02c34 100644
--- a/arch/powerpc/platforms/pseries/Kconfig
+++ b/arch/powerpc/platforms/pseries/Kconfig
@@ -2,8 +2,11 @@ config PPC_PSERIES
         depends on PPC64 && PPC_BOOK3S
         bool "IBM pSeries & new (POWER5-based) iSeries"
         select MPIC
+        select PCI_MSI
+        select XICS
         select PPC_I8259
         select PPC_RTAS
+        select PPC_RTAS_DAEMON
         select RTAS_ERROR_LOGGING
         select PPC_UDBG_16550
         select PPC_NATIVE
@@ -59,7 +62,7 @@ config PPC_SMLPAR
 
 config CMM
         tristate "Collaborative memory management"
-        depends on PPC_SMLPAR && !CRASH_DUMP
+        depends on PPC_SMLPAR
         default y
         help
           Select this option, if you want to enable the kernel interface
diff --git a/arch/powerpc/platforms/pseries/Makefile b/arch/powerpc/platforms/pseries/Makefile
index 790c0b872d4f..0ff5174ae4f5 100644
--- a/arch/powerpc/platforms/pseries/Makefile
+++ b/arch/powerpc/platforms/pseries/Makefile
@@ -7,8 +7,8 @@ EXTRA_CFLAGS		+= -DDEBUG
 endif
 
 obj-y                   := lpar.o hvCall.o nvram.o reconfig.o \
-                           setup.o iommu.o ras.o rtasd.o \
-                           firmware.o power.o
+                           setup.o iommu.o ras.o \
+                           firmware.o power.o dlpar.o
 obj-$(CONFIG_SMP)       += smp.o
 obj-$(CONFIG_XICS)      += xics.o
 obj-$(CONFIG_SCANLOG)   += scanlog.o
diff --git a/arch/powerpc/platforms/pseries/cmm.c b/arch/powerpc/platforms/pseries/cmm.c
index 6567439fe78d..a277f2e28dbc 100644
--- a/arch/powerpc/platforms/pseries/cmm.c
+++ b/arch/powerpc/platforms/pseries/cmm.c
@@ -38,19 +38,28 @@
 #include <asm/mmu.h>
 #include <asm/pgalloc.h>
 #include <asm/uaccess.h>
+#include <linux/memory.h>
 
 #include "plpar_wrappers.h"
 
 #define CMM_DRIVER_VERSION      "1.0.0"
 #define CMM_DEFAULT_DELAY       1
+#define CMM_HOTPLUG_DELAY       5
 #define CMM_DEBUG                       0
 #define CMM_DISABLE             0
 #define CMM_OOM_KB              1024
 #define CMM_MIN_MEM_MB          256
 #define KB2PAGES(_p)            ((_p)>>(PAGE_SHIFT-10))
 #define PAGES2KB(_p)            ((_p)<<(PAGE_SHIFT-10))
+/*
+ * The priority level tries to ensure that this notifier is called as
+ * late as possible to reduce thrashing in the shared memory pool.
+ */
+#define CMM_MEM_HOTPLUG_PRI     1
+#define CMM_MEM_ISOLATE_PRI     15
 
 static unsigned int delay = CMM_DEFAULT_DELAY;
+static unsigned int hotplug_delay = CMM_HOTPLUG_DELAY;
 static unsigned int oom_kb = CMM_OOM_KB;
 static unsigned int cmm_debug = CMM_DEBUG;
 static unsigned int cmm_disabled = CMM_DISABLE;
@@ -65,6 +74,10 @@ MODULE_VERSION(CMM_DRIVER_VERSION);
 module_param_named(delay, delay, uint, S_IRUGO | S_IWUSR);
 MODULE_PARM_DESC(delay, "Delay (in seconds) between polls to query hypervisor paging requests. "
                  "[Default=" __stringify(CMM_DEFAULT_DELAY) "]");
+module_param_named(hotplug_delay, hotplug_delay, uint, S_IRUGO | S_IWUSR);
+MODULE_PARM_DESC(delay, "Delay (in seconds) after memory hotplug remove "
+                 "before loaning resumes. "
+                 "[Default=" __stringify(CMM_HOTPLUG_DELAY) "]");
 module_param_named(oom_kb, oom_kb, uint, S_IRUGO | S_IWUSR);
 MODULE_PARM_DESC(oom_kb, "Amount of memory in kb to free on OOM. "
                  "[Default=" __stringify(CMM_OOM_KB) "]");
@@ -92,6 +105,9 @@ static unsigned long oom_freed_pages;
 static struct cmm_page_array *cmm_page_list;
 static DEFINE_SPINLOCK(cmm_lock);
 
+static DEFINE_MUTEX(hotplug_mutex);
+static int hotplug_occurred; /* protected by the hotplug mutex */
+
 static struct task_struct *cmm_thread_ptr;
 
 /**
@@ -110,6 +126,17 @@ static long cmm_alloc_pages(long nr)
         cmm_dbg("Begin request for %ld pages\n", nr);
 
         while (nr) {
+                /* Exit if a hotplug operation is in progress or occurred */
+                if (mutex_trylock(&hotplug_mutex)) {
+                        if (hotplug_occurred) {
+                                mutex_unlock(&hotplug_mutex);
+                                break;
+                        }
+                        mutex_unlock(&hotplug_mutex);
+                } else {
+                        break;
+                }
+
                 addr = __get_free_page(GFP_NOIO | __GFP_NOWARN |
                                        __GFP_NORETRY | __GFP_NOMEMALLOC);
                 if (!addr)
@@ -119,8 +146,9 @@ static long cmm_alloc_pages(long nr)
                 if (!pa || pa->index >= CMM_NR_PAGES) {
                         /* Need a new page for the page list. */
                         spin_unlock(&cmm_lock);
-                        npa = (struct cmm_page_array *)__get_free_page(GFP_NOIO | __GFP_NOWARN |
-                                                                       __GFP_NORETRY | __GFP_NOMEMALLOC);
+                        npa = (struct cmm_page_array *)__get_free_page(
+                                        GFP_NOIO | __GFP_NOWARN |
+                                        __GFP_NORETRY | __GFP_NOMEMALLOC);
                         if (!npa) {
                                 pr_info("%s: Can not allocate new page list\n", __func__);
                                 free_page(addr);
@@ -229,8 +257,9 @@ static void cmm_get_mpp(void)
 {
         int rc;
         struct hvcall_mpp_data mpp_data;
-        unsigned long active_pages_target;
-        signed long page_loan_request;
+        signed long active_pages_target, page_loan_request, target;
+        signed long total_pages = totalram_pages + loaned_pages;
+        signed long min_mem_pages = (min_mem_mb * 1024 * 1024) / PAGE_SIZE;
 
         rc = h_get_mpp(&mpp_data);
 
@@ -238,17 +267,25 @@ static void cmm_get_mpp(void)
                 return;
 
         page_loan_request = div_s64((s64)mpp_data.loan_request, PAGE_SIZE);
-        loaned_pages_target = page_loan_request + loaned_pages;
-        if (loaned_pages_target > oom_freed_pages)
-                loaned_pages_target -= oom_freed_pages;
+        target = page_loan_request + (signed long)loaned_pages;
+
+        if (target < 0 || total_pages < min_mem_pages)
+                target = 0;
+
+        if (target > oom_freed_pages)
+                target -= oom_freed_pages;
         else
-                loaned_pages_target = 0;
+                target = 0;
+
+        active_pages_target = total_pages - target;
 
-        active_pages_target = totalram_pages + loaned_pages - loaned_pages_target;
+        if (min_mem_pages > active_pages_target)
+                target = total_pages - min_mem_pages;
 
-        if ((min_mem_mb * 1024 * 1024) > (active_pages_target * PAGE_SIZE))
-                loaned_pages_target = totalram_pages + loaned_pages -
-                        ((min_mem_mb * 1024 * 1024) / PAGE_SIZE);
+        if (target < 0)
+                target = 0;
+
+        loaned_pages_target = target;
 
         cmm_dbg("delta = %ld, loaned = %lu, target = %lu, oom = %lu, totalram = %lu\n",
                 page_loan_request, loaned_pages, loaned_pages_target,
@@ -273,9 +310,28 @@ static int cmm_thread(void *dummy)
         while (1) {
                 timeleft = msleep_interruptible(delay * 1000);
 
-                if (kthread_should_stop() || timeleft) {
-                        loaned_pages_target = loaned_pages;
+                if (kthread_should_stop() || timeleft)
                         break;
+
+                if (mutex_trylock(&hotplug_mutex)) {
+                        if (hotplug_occurred) {
+                                hotplug_occurred = 0;
+                                mutex_unlock(&hotplug_mutex);
+                                cmm_dbg("Hotplug operation has occurred, "
+                                                "loaning activity suspended "
+                                                "for %d seconds.\n",
+                                                hotplug_delay);
+                                timeleft = msleep_interruptible(hotplug_delay *
+                                                1000);
+                                if (kthread_should_stop() || timeleft)
+                                        break;
+                                continue;
+                        }
+                        mutex_unlock(&hotplug_mutex);
+                } else {
+                        cmm_dbg("Hotplug operation in progress, activity "
+                                        "suspended\n");
+                        continue;
                 }
 
                 cmm_get_mpp();
@@ -405,6 +461,193 @@ static struct notifier_block cmm_reboot_nb = {
 };
 
 /**
+ * cmm_count_pages - Count the number of pages loaned in a particular range.
+ *
+ * @arg: memory_isolate_notify structure with address range and count
+ *
+ * Return value:
+ *      0 on success
+ **/
+static unsigned long cmm_count_pages(void *arg)
+{
+        struct memory_isolate_notify *marg = arg;
+        struct cmm_page_array *pa;
+        unsigned long start = (unsigned long)pfn_to_kaddr(marg->start_pfn);
+        unsigned long end = start + (marg->nr_pages << PAGE_SHIFT);
+        unsigned long idx;
+
+        spin_lock(&cmm_lock);
+        pa = cmm_page_list;
+        while (pa) {
+                if ((unsigned long)pa >= start && (unsigned long)pa < end)
+                        marg->pages_found++;
+                for (idx = 0; idx < pa->index; idx++)
+                        if (pa->page[idx] >= start && pa->page[idx] < end)
+                                marg->pages_found++;
+                pa = pa->next;
+        }
+        spin_unlock(&cmm_lock);
+        return 0;
+}
+
+/**
+ * cmm_memory_isolate_cb - Handle memory isolation notifier calls
+ * @self:       notifier block struct
+ * @action:     action to take
+ * @arg:        struct memory_isolate_notify data for handler
+ *
+ * Return value:
+ *      NOTIFY_OK or notifier error based on subfunction return value
+ **/
+static int cmm_memory_isolate_cb(struct notifier_block *self,
+                                 unsigned long action, void *arg)
+{
+        int ret = 0;
+
+        if (action == MEM_ISOLATE_COUNT)
+                ret = cmm_count_pages(arg);
+
+        if (ret)
+                ret = notifier_from_errno(ret);
+        else
+                ret = NOTIFY_OK;
+
+        return ret;
+}
+
+static struct notifier_block cmm_mem_isolate_nb = {
+        .notifier_call = cmm_memory_isolate_cb,
+        .priority = CMM_MEM_ISOLATE_PRI
+};
+
+/**
+ * cmm_mem_going_offline - Unloan pages where memory is to be removed
+ * @arg: memory_notify structure with page range to be offlined
+ *
+ * Return value:
+ *      0 on success
+ **/
+static int cmm_mem_going_offline(void *arg)
+{
+        struct memory_notify *marg = arg;
+        unsigned long start_page = (unsigned long)pfn_to_kaddr(marg->start_pfn);
+        unsigned long end_page = start_page + (marg->nr_pages << PAGE_SHIFT);
+        struct cmm_page_array *pa_curr, *pa_last, *npa;
+        unsigned long idx;
+        unsigned long freed = 0;
+
+        cmm_dbg("Memory going offline, searching 0x%lx (%ld pages).\n",
+                        start_page, marg->nr_pages);
+        spin_lock(&cmm_lock);
+
+        /* Search the page list for pages in the range to be offlined */
+        pa_last = pa_curr = cmm_page_list;
+        while (pa_curr) {
+                for (idx = (pa_curr->index - 1); (idx + 1) > 0; idx--) {
+                        if ((pa_curr->page[idx] < start_page) ||
+                            (pa_curr->page[idx] >= end_page))
+                                continue;
+
+                        plpar_page_set_active(__pa(pa_curr->page[idx]));
+                        free_page(pa_curr->page[idx]);
+                        freed++;
+                        loaned_pages--;
+                        totalram_pages++;
+                        pa_curr->page[idx] = pa_last->page[--pa_last->index];
+                        if (pa_last->index == 0) {
+                                if (pa_curr == pa_last)
+                                        pa_curr = pa_last->next;
+                                pa_last = pa_last->next;
+                                free_page((unsigned long)cmm_page_list);
+                                cmm_page_list = pa_last;
+                                continue;
+                        }
+                }
+                pa_curr = pa_curr->next;
+        }
+
+        /* Search for page list structures in the range to be offlined */
+        pa_last = NULL;
+        pa_curr = cmm_page_list;
+        while (pa_curr) {
+                if (((unsigned long)pa_curr >= start_page) &&
+                                ((unsigned long)pa_curr < end_page)) {
+                        npa = (struct cmm_page_array *)__get_free_page(
+                                        GFP_NOIO | __GFP_NOWARN |
+                                        __GFP_NORETRY | __GFP_NOMEMALLOC);
+                        if (!npa) {
+                                spin_unlock(&cmm_lock);
+                                cmm_dbg("Failed to allocate memory for list "
+                                                "management. Memory hotplug "
+                                                "failed.\n");
+                                return ENOMEM;
+                        }
+                        memcpy(npa, pa_curr, PAGE_SIZE);
+                        if (pa_curr == cmm_page_list)
+                                cmm_page_list = npa;
+                        if (pa_last)
+                                pa_last->next = npa;
+                        free_page((unsigned long) pa_curr);
+                        freed++;
+                        pa_curr = npa;
+                }
+
+                pa_last = pa_curr;
+                pa_curr = pa_curr->next;
+        }
+
+        spin_unlock(&cmm_lock);
+        cmm_dbg("Released %ld pages in the search range.\n", freed);
+
+        return 0;
+}
+
+/**
+ * cmm_memory_cb - Handle memory hotplug notifier calls
+ * @self:       notifier block struct
+ * @action:     action to take
+ * @arg:        struct memory_notify data for handler
+ *
+ * Return value:
+ *      NOTIFY_OK or notifier error based on subfunction return value
+ *
+ **/
+static int cmm_memory_cb(struct notifier_block *self,
+                        unsigned long action, void *arg)
+{
+        int ret = 0;
+
+        switch (action) {
+        case MEM_GOING_OFFLINE:
+                mutex_lock(&hotplug_mutex);
+                hotplug_occurred = 1;
+                ret = cmm_mem_going_offline(arg);
+                break;
+        case MEM_OFFLINE:
+        case MEM_CANCEL_OFFLINE:
+                mutex_unlock(&hotplug_mutex);
+                cmm_dbg("Memory offline operation complete.\n");
+                break;
+        case MEM_GOING_ONLINE:
+        case MEM_ONLINE:
+        case MEM_CANCEL_ONLINE:
+                break;
+        }
+
+        if (ret)
+                ret = notifier_from_errno(ret);
+        else
+                ret = NOTIFY_OK;
+
+        return ret;
+}
+
+static struct notifier_block cmm_mem_nb = {
+        .notifier_call = cmm_memory_cb,
+        .priority = CMM_MEM_HOTPLUG_PRI
+};
+
+/**
  * cmm_init - Module initialization
  *
  * Return value:
@@ -426,18 +669,24 @@ static int cmm_init(void)
         if ((rc = cmm_sysfs_register(&cmm_sysdev)))
                 goto out_reboot_notifier;
 
+        if (register_memory_notifier(&cmm_mem_nb) ||
+            register_memory_isolate_notifier(&cmm_mem_isolate_nb))
+                goto out_unregister_notifier;
+
         if (cmm_disabled)
                 return rc;
 
         cmm_thread_ptr = kthread_run(cmm_thread, NULL, "cmmthread");
         if (IS_ERR(cmm_thread_ptr)) {
                 rc = PTR_ERR(cmm_thread_ptr);
-                goto out_unregister_sysfs;
+                goto out_unregister_notifier;
         }
 
         return rc;
 
-out_unregister_sysfs:
+out_unregister_notifier:
+        unregister_memory_notifier(&cmm_mem_nb);
+        unregister_memory_isolate_notifier(&cmm_mem_isolate_nb);
         cmm_unregister_sysfs(&cmm_sysdev);
 out_reboot_notifier:
         unregister_reboot_notifier(&cmm_reboot_nb);
@@ -458,6 +707,8 @@ static void cmm_exit(void)
                 kthread_stop(cmm_thread_ptr);
         unregister_oom_notifier(&cmm_oom_nb);
         unregister_reboot_notifier(&cmm_reboot_nb);
+        unregister_memory_notifier(&cmm_mem_nb);
+        unregister_memory_isolate_notifier(&cmm_mem_isolate_nb);
         cmm_free_pages(loaned_pages);
         cmm_unregister_sysfs(&cmm_sysdev);
 }
diff --git a/arch/powerpc/platforms/pseries/dlpar.c b/arch/powerpc/platforms/pseries/dlpar.c
new file mode 100644
index 000000000000..37bce52526da
--- /dev/null
+++ b/arch/powerpc/platforms/pseries/dlpar.c
@@ -0,0 +1,548 @@
+/*
+ * Support for dynamic reconfiguration for PCI, Memory, and CPU
+ * Hotplug and Dynamic Logical Partitioning on RPA platforms.
+ *
+ * Copyright (C) 2009 Nathan Fontenot
+ * Copyright (C) 2009 IBM Corporation
+ *
+ * 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.
+ */
+
+#include <linux/kernel.h>
+#include <linux/kref.h>
+#include <linux/notifier.h>
+#include <linux/proc_fs.h>
+#include <linux/spinlock.h>
+#include <linux/cpu.h>
+#include "offline_states.h"
+
+#include <asm/prom.h>
+#include <asm/machdep.h>
+#include <asm/uaccess.h>
+#include <asm/rtas.h>
+#include <asm/pSeries_reconfig.h>
+
+struct cc_workarea {
+        u32     drc_index;
+        u32     zero;
+        u32     name_offset;
+        u32     prop_length;
+        u32     prop_offset;
+};
+
+static void dlpar_free_cc_property(struct property *prop)
+{
+        kfree(prop->name);
+        kfree(prop->value);
+        kfree(prop);
+}
+
+static struct property *dlpar_parse_cc_property(struct cc_workarea *ccwa)
+{
+        struct property *prop;
+        char *name;
+        char *value;
+
+        prop = kzalloc(sizeof(*prop), GFP_KERNEL);
+        if (!prop)
+                return NULL;
+
+        name = (char *)ccwa + ccwa->name_offset;
+        prop->name = kstrdup(name, GFP_KERNEL);
+
+        prop->length = ccwa->prop_length;
+        value = (char *)ccwa + ccwa->prop_offset;
+        prop->value = kzalloc(prop->length, GFP_KERNEL);
+        if (!prop->value) {
+                dlpar_free_cc_property(prop);
+                return NULL;
+        }
+
+        memcpy(prop->value, value, prop->length);
+        return prop;
+}
+
+static struct device_node *dlpar_parse_cc_node(struct cc_workarea *ccwa)
+{
+        struct device_node *dn;
+        char *name;
+
+        dn = kzalloc(sizeof(*dn), GFP_KERNEL);
+        if (!dn)
+                return NULL;
+
+        /* The configure connector reported name does not contain a
+         * preceeding '/', so we allocate a buffer large enough to
+         * prepend this to the full_name.
+         */
+        name = (char *)ccwa + ccwa->name_offset;
+        dn->full_name = kmalloc(strlen(name) + 2, GFP_KERNEL);
+        if (!dn->full_name) {
+                kfree(dn);
+                return NULL;
+        }
+
+        sprintf(dn->full_name, "/%s", name);
+        return dn;
+}
+
+static void dlpar_free_one_cc_node(struct device_node *dn)
+{
+        struct property *prop;
+
+        while (dn->properties) {
+                prop = dn->properties;
+                dn->properties = prop->next;
+                dlpar_free_cc_property(prop);
+        }
+
+        kfree(dn->full_name);
+        kfree(dn);
+}
+
+static void dlpar_free_cc_nodes(struct device_node *dn)
+{
+        if (dn->child)
+                dlpar_free_cc_nodes(dn->child);
+
+        if (dn->sibling)
+                dlpar_free_cc_nodes(dn->sibling);
+
+        dlpar_free_one_cc_node(dn);
+}
+
+#define NEXT_SIBLING    1
+#define NEXT_CHILD      2
+#define NEXT_PROPERTY   3
+#define PREV_PARENT     4
+#define MORE_MEMORY     5
+#define CALL_AGAIN      -2
+#define ERR_CFG_USE     -9003
+
+struct device_node *dlpar_configure_connector(u32 drc_index)
+{
+        struct device_node *dn;
+        struct device_node *first_dn = NULL;
+        struct device_node *last_dn = NULL;
+        struct property *property;
+        struct property *last_property = NULL;
+        struct cc_workarea *ccwa;
+        int cc_token;
+        int rc;
+
+        cc_token = rtas_token("ibm,configure-connector");
+        if (cc_token == RTAS_UNKNOWN_SERVICE)
+                return NULL;
+
+        spin_lock(&rtas_data_buf_lock);
+        ccwa = (struct cc_workarea *)&rtas_data_buf[0];
+        ccwa->drc_index = drc_index;
+        ccwa->zero = 0;
+
+        rc = rtas_call(cc_token, 2, 1, NULL, rtas_data_buf, NULL);
+        while (rc) {
+                switch (rc) {
+                case NEXT_SIBLING:
+                        dn = dlpar_parse_cc_node(ccwa);
+                        if (!dn)
+                                goto cc_error;
+
+                        dn->parent = last_dn->parent;
+                        last_dn->sibling = dn;
+                        last_dn = dn;
+                        break;
+
+                case NEXT_CHILD:
+                        dn = dlpar_parse_cc_node(ccwa);
+                        if (!dn)
+                                goto cc_error;
+
+                        if (!first_dn)
+                                first_dn = dn;
+                        else {
+                                dn->parent = last_dn;
+                                if (last_dn)
+                                        last_dn->child = dn;
+                        }
+
+                        last_dn = dn;
+                        break;
+
+                case NEXT_PROPERTY:
+                        property = dlpar_parse_cc_property(ccwa);
+                        if (!property)
+                                goto cc_error;
+
+                        if (!last_dn->properties)
+                                last_dn->properties = property;
+                        else
+                                last_property->next = property;
+
+                        last_property = property;
+                        break;
+
+                case PREV_PARENT:
+                        last_dn = last_dn->parent;
+                        break;
+
+                case CALL_AGAIN:
+                        break;
+
+                case MORE_MEMORY:
+                case ERR_CFG_USE:
+                default:
+                        printk(KERN_ERR "Unexpected Error (%d) "
+                               "returned from configure-connector\n", rc);
+                        goto cc_error;
+                }
+
+                rc = rtas_call(cc_token, 2, 1, NULL, rtas_data_buf, NULL);
+        }
+
+        spin_unlock(&rtas_data_buf_lock);
+        return first_dn;
+
+cc_error:
+        if (first_dn)
+                dlpar_free_cc_nodes(first_dn);
+        spin_unlock(&rtas_data_buf_lock);
+        return NULL;
+}
+
+static struct device_node *derive_parent(const char *path)
+{
+        struct device_node *parent;
+        char *last_slash;
+
+        last_slash = strrchr(path, '/');
+        if (last_slash == path) {
+                parent = of_find_node_by_path("/");
+        } else {
+                char *parent_path;
+                int parent_path_len = last_slash - path + 1;
+                parent_path = kmalloc(parent_path_len, GFP_KERNEL);
+                if (!parent_path)
+                        return NULL;
+
+                strlcpy(parent_path, path, parent_path_len);
+                parent = of_find_node_by_path(parent_path);
+                kfree(parent_path);
+        }
+
+        return parent;
+}
+
+int dlpar_attach_node(struct device_node *dn)
+{
+#ifdef CONFIG_PROC_DEVICETREE
+        struct proc_dir_entry *ent;
+#endif
+        int rc;
+
+        of_node_set_flag(dn, OF_DYNAMIC);
+        kref_init(&dn->kref);
+        dn->parent = derive_parent(dn->full_name);
+        if (!dn->parent)
+                return -ENOMEM;
+
+        rc = blocking_notifier_call_chain(&pSeries_reconfig_chain,
+                                          PSERIES_RECONFIG_ADD, dn);
+        if (rc == NOTIFY_BAD) {
+                printk(KERN_ERR "Failed to add device node %s\n",
+                       dn->full_name);
+                return -ENOMEM; /* For now, safe to assume kmalloc failure */
+        }
+
+        of_attach_node(dn);
+
+#ifdef CONFIG_PROC_DEVICETREE
+        ent = proc_mkdir(strrchr(dn->full_name, '/') + 1, dn->parent->pde);
+        if (ent)
+                proc_device_tree_add_node(dn, ent);
+#endif
+
+        of_node_put(dn->parent);
+        return 0;
+}
+
+int dlpar_detach_node(struct device_node *dn)
+{
+#ifdef CONFIG_PROC_DEVICETREE
+        struct device_node *parent = dn->parent;
+        struct property *prop = dn->properties;
+
+        while (prop) {
+                remove_proc_entry(prop->name, dn->pde);
+                prop = prop->next;
+        }
+
+        if (dn->pde)
+                remove_proc_entry(dn->pde->name, parent->pde);
+#endif
+
+        blocking_notifier_call_chain(&pSeries_reconfig_chain,
+                            PSERIES_RECONFIG_REMOVE, dn);
+        of_detach_node(dn);
+        of_node_put(dn); /* Must decrement the refcount */
+
+        return 0;
+}
+
+#define DR_ENTITY_SENSE         9003
+#define DR_ENTITY_PRESENT       1
+#define DR_ENTITY_UNUSABLE      2
+#define ALLOCATION_STATE        9003
+#define ALLOC_UNUSABLE          0
+#define ALLOC_USABLE            1
+#define ISOLATION_STATE         9001
+#define ISOLATE                 0
+#define UNISOLATE               1
+
+int dlpar_acquire_drc(u32 drc_index)
+{
+        int dr_status, rc;
+
+        rc = rtas_call(rtas_token("get-sensor-state"), 2, 2, &dr_status,
+                       DR_ENTITY_SENSE, drc_index);
+        if (rc || dr_status != DR_ENTITY_UNUSABLE)
+                return -1;
+
+        rc = rtas_set_indicator(ALLOCATION_STATE, drc_index, ALLOC_USABLE);
+        if (rc)
+                return rc;
+
+        rc = rtas_set_indicator(ISOLATION_STATE, drc_index, UNISOLATE);
+        if (rc) {
+                rtas_set_indicator(ALLOCATION_STATE, drc_index, ALLOC_UNUSABLE);
+                return rc;
+        }
+
+        return 0;
+}
+
+int dlpar_release_drc(u32 drc_index)
+{
+        int dr_status, rc;
+
+        rc = rtas_call(rtas_token("get-sensor-state"), 2, 2, &dr_status,
+                       DR_ENTITY_SENSE, drc_index);
+        if (rc || dr_status != DR_ENTITY_PRESENT)
+                return -1;
+
+        rc = rtas_set_indicator(ISOLATION_STATE, drc_index, ISOLATE);
+        if (rc)
+                return rc;
+
+        rc = rtas_set_indicator(ALLOCATION_STATE, drc_index, ALLOC_UNUSABLE);
+        if (rc) {
+                rtas_set_indicator(ISOLATION_STATE, drc_index, UNISOLATE);
+                return rc;
+        }
+
+        return 0;
+}
+
+#ifdef CONFIG_ARCH_CPU_PROBE_RELEASE
+
+static int dlpar_online_cpu(struct device_node *dn)
+{
+        int rc = 0;
+        unsigned int cpu;
+        int len, nthreads, i;
+        const u32 *intserv;
+
+        intserv = of_get_property(dn, "ibm,ppc-interrupt-server#s", &len);
+        if (!intserv)
+                return -EINVAL;
+
+        nthreads = len / sizeof(u32);
+
+        cpu_maps_update_begin();
+        for (i = 0; i < nthreads; i++) {
+                for_each_present_cpu(cpu) {
+                        if (get_hard_smp_processor_id(cpu) != intserv[i])
+                                continue;
+                        BUG_ON(get_cpu_current_state(cpu)
+                                        != CPU_STATE_OFFLINE);
+                        cpu_maps_update_done();
+                        rc = cpu_up(cpu);
+                        if (rc)
+                                goto out;
+                        cpu_maps_update_begin();
+
+                        break;
+                }
+                if (cpu == num_possible_cpus())
+                        printk(KERN_WARNING "Could not find cpu to online "
+                               "with physical id 0x%x\n", intserv[i]);
+        }
+        cpu_maps_update_done();
+
+out:
+        return rc;
+
+}
+
+static ssize_t dlpar_cpu_probe(const char *buf, size_t count)
+{
+        struct device_node *dn;
+        unsigned long drc_index;
+        char *cpu_name;
+        int rc;
+
+        cpu_hotplug_driver_lock();
+        rc = strict_strtoul(buf, 0, &drc_index);
+        if (rc) {
+                rc = -EINVAL;
+                goto out;
+        }
+
+        dn = dlpar_configure_connector(drc_index);
+        if (!dn) {
+                rc = -EINVAL;
+                goto out;
+        }
+
+        /* configure-connector reports cpus as living in the base
+         * directory of the device tree.  CPUs actually live in the
+         * cpus directory so we need to fixup the full_name.
+         */
+        cpu_name = kzalloc(strlen(dn->full_name) + strlen("/cpus") + 1,
+                           GFP_KERNEL);
+        if (!cpu_name) {
+                dlpar_free_cc_nodes(dn);
+                rc = -ENOMEM;
+                goto out;
+        }
+
+        sprintf(cpu_name, "/cpus%s", dn->full_name);
+        kfree(dn->full_name);
+        dn->full_name = cpu_name;
+
+        rc = dlpar_acquire_drc(drc_index);
+        if (rc) {
+                dlpar_free_cc_nodes(dn);
+                rc = -EINVAL;
+                goto out;
+        }
+
+        rc = dlpar_attach_node(dn);
+        if (rc) {
+                dlpar_release_drc(drc_index);
+                dlpar_free_cc_nodes(dn);
+        }
+
+        rc = dlpar_online_cpu(dn);
+out:
+        cpu_hotplug_driver_unlock();
+
+        return rc ? rc : count;
+}
+
+static int dlpar_offline_cpu(struct device_node *dn)
+{
+        int rc = 0;
+        unsigned int cpu;
+        int len, nthreads, i;
+        const u32 *intserv;
+
+        intserv = of_get_property(dn, "ibm,ppc-interrupt-server#s", &len);
+        if (!intserv)
+                return -EINVAL;
+
+        nthreads = len / sizeof(u32);
+
+        cpu_maps_update_begin();
+        for (i = 0; i < nthreads; i++) {
+                for_each_present_cpu(cpu) {
+                        if (get_hard_smp_processor_id(cpu) != intserv[i])
+                                continue;
+
+                        if (get_cpu_current_state(cpu) == CPU_STATE_OFFLINE)
+                                break;
+
+                        if (get_cpu_current_state(cpu) == CPU_STATE_ONLINE) {
+                                cpu_maps_update_done();
+                                rc = cpu_down(cpu);
+                                if (rc)
+                                        goto out;
+                                cpu_maps_update_begin();
+                                break;
+
+                        }
+
+                        /*
+                         * The cpu is in CPU_STATE_INACTIVE.
+                         * Upgrade it's state to CPU_STATE_OFFLINE.
+                         */
+                        set_preferred_offline_state(cpu, CPU_STATE_OFFLINE);
+                        BUG_ON(plpar_hcall_norets(H_PROD, intserv[i])
+                                                                != H_SUCCESS);
+                        __cpu_die(cpu);
+                        break;
+                }
+                if (cpu == num_possible_cpus())
+                        printk(KERN_WARNING "Could not find cpu to offline "
+                               "with physical id 0x%x\n", intserv[i]);
+        }
+        cpu_maps_update_done();
+
+out:
+        return rc;
+
+}
+
+static ssize_t dlpar_cpu_release(const char *buf, size_t count)
+{
+        struct device_node *dn;
+        const u32 *drc_index;
+        int rc;
+
+        dn = of_find_node_by_path(buf);
+        if (!dn)
+                return -EINVAL;
+
+        drc_index = of_get_property(dn, "ibm,my-drc-index", NULL);
+        if (!drc_index) {
+                of_node_put(dn);
+                return -EINVAL;
+        }
+
+        cpu_hotplug_driver_lock();
+        rc = dlpar_offline_cpu(dn);
+        if (rc) {
+                of_node_put(dn);
+                rc = -EINVAL;
+                goto out;
+        }
+
+        rc = dlpar_release_drc(*drc_index);
+        if (rc) {
+                of_node_put(dn);
+                goto out;
+        }
+
+        rc = dlpar_detach_node(dn);
+        if (rc) {
+                dlpar_acquire_drc(*drc_index);
+                goto out;
+        }
+
+        of_node_put(dn);
+out:
+        cpu_hotplug_driver_unlock();
+        return rc ? rc : count;
+}
+
+static int __init pseries_dlpar_init(void)
+{
+        ppc_md.cpu_probe = dlpar_cpu_probe;
+        ppc_md.cpu_release = dlpar_cpu_release;
+
+        return 0;
+}
+machine_device_initcall(pseries, pseries_dlpar_init);
+
+#endif /* CONFIG_ARCH_CPU_PROBE_RELEASE */
diff --git a/arch/powerpc/platforms/pseries/dtl.c b/arch/powerpc/platforms/pseries/dtl.c
index 937a544a236d..c5f3116b6ca5 100644
--- a/arch/powerpc/platforms/pseries/dtl.c
+++ b/arch/powerpc/platforms/pseries/dtl.c
@@ -54,7 +54,7 @@ struct dtl {
         int                     buf_entries;
         u64                     last_idx;
 };
-static DEFINE_PER_CPU(struct dtl, dtl);
+static DEFINE_PER_CPU(struct dtl, cpu_dtl);
 
 /*
  * Dispatch trace log event mask:
@@ -261,7 +261,7 @@ static int dtl_init(void)
 
         /* set up the per-cpu log structures */
         for_each_possible_cpu(i) {
-                struct dtl *dtl = &per_cpu(dtl, i);
+                struct dtl *dtl = &per_cpu(cpu_dtl, i);
                 dtl->cpu = i;
 
                 rc = dtl_setup_file(dtl);
diff --git a/arch/powerpc/platforms/pseries/eeh_driver.c b/arch/powerpc/platforms/pseries/eeh_driver.c
index 0e8db6771252..ef8e45448480 100644
--- a/arch/powerpc/platforms/pseries/eeh_driver.c
+++ b/arch/powerpc/platforms/pseries/eeh_driver.c
@@ -63,22 +63,6 @@ static void print_device_node_tree(struct pci_dn *pdn, int dent)
 }
 #endif
 
-/** 
- * irq_in_use - return true if this irq is being used 
- */
-static int irq_in_use(unsigned int irq)
-{
-        int rc = 0;
-        unsigned long flags;
-   struct irq_desc *desc = irq_desc + irq;
-
-        spin_lock_irqsave(&desc->lock, flags);
-        if (desc->action)
-                rc = 1;
-        spin_unlock_irqrestore(&desc->lock, flags);
-        return rc;
-}
-
 /**
  * eeh_disable_irq - disable interrupt for the recovering device
  */
@@ -93,7 +77,7 @@ static void eeh_disable_irq(struct pci_dev *dev)
         if (dev->msi_enabled || dev->msix_enabled)
                 return;
 
-        if (!irq_in_use(dev->irq))
+        if (!irq_has_action(dev->irq))
                 return;
 
         PCI_DN(dn)->eeh_mode |= EEH_MODE_IRQ_DISABLED;
diff --git a/arch/powerpc/platforms/pseries/hotplug-cpu.c b/arch/powerpc/platforms/pseries/hotplug-cpu.c
index ebff6d9a4e39..6ea4698d9176 100644
--- a/arch/powerpc/platforms/pseries/hotplug-cpu.c
+++ b/arch/powerpc/platforms/pseries/hotplug-cpu.c
@@ -30,6 +30,7 @@
 #include <asm/pSeries_reconfig.h>
 #include "xics.h"
 #include "plpar_wrappers.h"
+#include "offline_states.h"
 
 /* This version can't take the spinlock, because it never returns */
 static struct rtas_args rtas_stop_self_args = {
@@ -39,6 +40,55 @@ static struct rtas_args rtas_stop_self_args = {
         .rets = &rtas_stop_self_args.args[0],
 };
 
+static DEFINE_PER_CPU(enum cpu_state_vals, preferred_offline_state) =
+                                                        CPU_STATE_OFFLINE;
+static DEFINE_PER_CPU(enum cpu_state_vals, current_state) = CPU_STATE_OFFLINE;
+
+static enum cpu_state_vals default_offline_state = CPU_STATE_OFFLINE;
+
+static int cede_offline_enabled __read_mostly = 1;
+
+/*
+ * Enable/disable cede_offline when available.
+ */
+static int __init setup_cede_offline(char *str)
+{
+        if (!strcmp(str, "off"))
+                cede_offline_enabled = 0;
+        else if (!strcmp(str, "on"))
+                cede_offline_enabled = 1;
+        else
+                return 0;
+        return 1;
+}
+
+__setup("cede_offline=", setup_cede_offline);
+
+enum cpu_state_vals get_cpu_current_state(int cpu)
+{
+        return per_cpu(current_state, cpu);
+}
+
+void set_cpu_current_state(int cpu, enum cpu_state_vals state)
+{
+        per_cpu(current_state, cpu) = state;
+}
+
+enum cpu_state_vals get_preferred_offline_state(int cpu)
+{
+        return per_cpu(preferred_offline_state, cpu);
+}
+
+void set_preferred_offline_state(int cpu, enum cpu_state_vals state)
+{
+        per_cpu(preferred_offline_state, cpu) = state;
+}
+
+void set_default_offline_state(int cpu)
+{
+        per_cpu(preferred_offline_state, cpu) = default_offline_state;
+}
+
 static void rtas_stop_self(void)
 {
         struct rtas_args *args = &rtas_stop_self_args;
@@ -56,11 +106,61 @@ static void rtas_stop_self(void)
 
 static void pseries_mach_cpu_die(void)
 {
+        unsigned int cpu = smp_processor_id();
+        unsigned int hwcpu = hard_smp_processor_id();
+        u8 cede_latency_hint = 0;
+
         local_irq_disable();
         idle_task_exit();
         xics_teardown_cpu();
-        unregister_slb_shadow(hard_smp_processor_id(), __pa(get_slb_shadow()));
-        rtas_stop_self();
+
+        if (get_preferred_offline_state(cpu) == CPU_STATE_INACTIVE) {
+                set_cpu_current_state(cpu, CPU_STATE_INACTIVE);
+                cede_latency_hint = 2;
+
+                get_lppaca()->idle = 1;
+                if (!get_lppaca()->shared_proc)
+                        get_lppaca()->donate_dedicated_cpu = 1;
+
+                printk(KERN_INFO
+                        "cpu %u (hwid %u) ceding for offline with hint %d\n",
+                        cpu, hwcpu, cede_latency_hint);
+                while (get_preferred_offline_state(cpu) == CPU_STATE_INACTIVE) {
+                        extended_cede_processor(cede_latency_hint);
+                        printk(KERN_INFO "cpu %u (hwid %u) returned from cede.\n",
+                                cpu, hwcpu);
+                        printk(KERN_INFO
+                        "Decrementer value = %x Timebase value = %llx\n",
+                        get_dec(), get_tb());
+                }
+
+                printk(KERN_INFO "cpu %u (hwid %u) got prodded to go online\n",
+                        cpu, hwcpu);
+
+                if (!get_lppaca()->shared_proc)
+                        get_lppaca()->donate_dedicated_cpu = 0;
+                get_lppaca()->idle = 0;
+        }
+
+        if (get_preferred_offline_state(cpu) == CPU_STATE_ONLINE) {
+                unregister_slb_shadow(hwcpu, __pa(get_slb_shadow()));
+
+                /*
+                 * NOTE: Calling start_secondary() here for now to
+                 * start new context.
+                 * However, need to do it cleanly by resetting the
+                 * stack pointer.
+                 */
+                start_secondary();
+
+        } else if (get_preferred_offline_state(cpu) == CPU_STATE_OFFLINE) {
+
+                set_cpu_current_state(cpu, CPU_STATE_OFFLINE);
+                unregister_slb_shadow(hard_smp_processor_id(),
+                                        __pa(get_slb_shadow()));
+                rtas_stop_self();
+        }
+
         /* Should never get here... */
         BUG();
         for(;;);
@@ -106,18 +206,43 @@ static int pseries_cpu_disable(void)
         return 0;
 }
 
+/*
+ * pseries_cpu_die: Wait for the cpu to die.
+ * @cpu: logical processor id of the CPU whose death we're awaiting.
+ *
+ * This function is called from the context of the thread which is performing
+ * the cpu-offline. Here we wait for long enough to allow the cpu in question
+ * to self-destroy so that the cpu-offline thread can send the CPU_DEAD
+ * notifications.
+ *
+ * OTOH, pseries_mach_cpu_die() is called by the @cpu when it wants to
+ * self-destruct.
+ */
 static void pseries_cpu_die(unsigned int cpu)
 {
         int tries;
-        int cpu_status;
+        int cpu_status = 1;
         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;
-                cpu_relax();
+        if (get_preferred_offline_state(cpu) == CPU_STATE_INACTIVE) {
+                cpu_status = 1;
+                for (tries = 0; tries < 1000; tries++) {
+                        if (get_cpu_current_state(cpu) == CPU_STATE_INACTIVE) {
+                                cpu_status = 0;
+                                break;
+                        }
+                        cpu_relax();
+                }
+        } else if (get_preferred_offline_state(cpu) == CPU_STATE_OFFLINE) {
+
+                for (tries = 0; tries < 25; tries++) {
+                        cpu_status = query_cpu_stopped(pcpu);
+                        if (cpu_status == 0 || cpu_status == -1)
+                                break;
+                        cpu_relax();
+                }
         }
+
         if (cpu_status != 0) {
                 printk("Querying DEAD? cpu %i (%i) shows %i\n",
                        cpu, pcpu, cpu_status);
@@ -252,10 +377,41 @@ static struct notifier_block pseries_smp_nb = {
         .notifier_call = pseries_smp_notifier,
 };
 
+#define MAX_CEDE_LATENCY_LEVELS         4
+#define CEDE_LATENCY_PARAM_LENGTH       10
+#define CEDE_LATENCY_PARAM_MAX_LENGTH   \
+        (MAX_CEDE_LATENCY_LEVELS * CEDE_LATENCY_PARAM_LENGTH * sizeof(char))
+#define CEDE_LATENCY_TOKEN              45
+
+static char cede_parameters[CEDE_LATENCY_PARAM_MAX_LENGTH];
+
+static int parse_cede_parameters(void)
+{
+        int call_status;
+
+        memset(cede_parameters, 0, CEDE_LATENCY_PARAM_MAX_LENGTH);
+        call_status = rtas_call(rtas_token("ibm,get-system-parameter"), 3, 1,
+                                NULL,
+                                CEDE_LATENCY_TOKEN,
+                                __pa(cede_parameters),
+                                CEDE_LATENCY_PARAM_MAX_LENGTH);
+
+        if (call_status != 0)
+                printk(KERN_INFO "CEDE_LATENCY: \
+                        %s %s Error calling get-system-parameter(0x%x)\n",
+                        __FILE__, __func__, call_status);
+        else
+                printk(KERN_INFO "CEDE_LATENCY: \
+                        get-system-parameter successful.\n");
+
+        return call_status;
+}
+
 static int __init pseries_cpu_hotplug_init(void)
 {
         struct device_node *np;
         const char *typep;
+        int cpu;
 
         for_each_node_by_name(np, "interrupt-controller") {
                 typep = of_get_property(np, "compatible", NULL);
@@ -283,8 +439,16 @@ static int __init pseries_cpu_hotplug_init(void)
         smp_ops->cpu_die = pseries_cpu_die;
 
         /* Processors can be added/removed only on LPAR */
-        if (firmware_has_feature(FW_FEATURE_LPAR))
+        if (firmware_has_feature(FW_FEATURE_LPAR)) {
                 pSeries_reconfig_notifier_register(&pseries_smp_nb);
+                cpu_maps_update_begin();
+                if (cede_offline_enabled && parse_cede_parameters() == 0) {
+                        default_offline_state = CPU_STATE_INACTIVE;
+                        for_each_online_cpu(cpu)
+                                set_default_offline_state(cpu);
+                }
+                cpu_maps_update_done();
+        }
 
         return 0;
 }
diff --git a/arch/powerpc/platforms/pseries/hvCall.S b/arch/powerpc/platforms/pseries/hvCall.S
index c1427b3634ec..383a5d0e9818 100644
--- a/arch/powerpc/platforms/pseries/hvCall.S
+++ b/arch/powerpc/platforms/pseries/hvCall.S
@@ -14,68 +14,94 @@
         
 #define STK_PARM(i)     (48 + ((i)-3)*8)
 
-#ifdef CONFIG_HCALL_STATS
+#ifdef CONFIG_TRACEPOINTS
+
+        .section        ".toc","aw"
+
+        .globl hcall_tracepoint_refcount
+hcall_tracepoint_refcount:
+        .llong  0
+
+        .section        ".text"
+
 /*
  * precall must preserve all registers.  use unused STK_PARM()
- * areas to save snapshots and opcode.
+ * areas to save snapshots and opcode. We branch around this
+ * in early init (eg when populating the MMU hashtable) by using an
+ * unconditional cpu feature.
  */
-#define HCALL_INST_PRECALL                                      \
-        std     r3,STK_PARM(r3)(r1);    /* save opcode */       \
-        mftb    r0;                     /* get timebase and */  \
-        std     r0,STK_PARM(r5)(r1);    /* save for later */    \
+#define HCALL_INST_PRECALL(FIRST_REG)                           \
 BEGIN_FTR_SECTION;                                              \
-        mfspr   r0,SPRN_PURR;           /* get PURR and */      \
-        std     r0,STK_PARM(r6)(r1);    /* save for later */    \
-END_FTR_SECTION_IFSET(CPU_FTR_PURR);
-        
+        b       1f;                                             \
+END_FTR_SECTION(0, 1);                                          \
+        ld      r12,hcall_tracepoint_refcount@toc(r2);          \
+        cmpdi   r12,0;                                          \
+        beq+    1f;                                             \
+        mflr    r0;                                             \
+        std     r3,STK_PARM(r3)(r1);                            \
+        std     r4,STK_PARM(r4)(r1);                            \
+        std     r5,STK_PARM(r5)(r1);                            \
+        std     r6,STK_PARM(r6)(r1);                            \
+        std     r7,STK_PARM(r7)(r1);                            \
+        std     r8,STK_PARM(r8)(r1);                            \
+        std     r9,STK_PARM(r9)(r1);                            \
+        std     r10,STK_PARM(r10)(r1);                          \
+        std     r0,16(r1);                                      \
+        addi    r4,r1,STK_PARM(FIRST_REG);                      \
+        stdu    r1,-STACK_FRAME_OVERHEAD(r1);                   \
+        bl      .__trace_hcall_entry;                           \
+        addi    r1,r1,STACK_FRAME_OVERHEAD;                     \
+        ld      r0,16(r1);                                      \
+        ld      r3,STK_PARM(r3)(r1);                            \
+        ld      r4,STK_PARM(r4)(r1);                            \
+        ld      r5,STK_PARM(r5)(r1);                            \
+        ld      r6,STK_PARM(r6)(r1);                            \
+        ld      r7,STK_PARM(r7)(r1);                            \
+        ld      r8,STK_PARM(r8)(r1);                            \
+        ld      r9,STK_PARM(r9)(r1);                            \
+        ld      r10,STK_PARM(r10)(r1);                          \
+        mtlr    r0;                                             \
+1:
+
 /*
  * postcall is performed immediately before function return which
  * allows liberal use of volatile registers.  We branch around this
  * in early init (eg when populating the MMU hashtable) by using an
  * unconditional cpu feature.
  */
-#define HCALL_INST_POSTCALL                                     \
+#define __HCALL_INST_POSTCALL                                   \
 BEGIN_FTR_SECTION;                                              \
         b       1f;                                             \
 END_FTR_SECTION(0, 1);                                          \
-        ld      r4,STK_PARM(r3)(r1);    /* validate opcode */   \
-        cmpldi  cr7,r4,MAX_HCALL_OPCODE;                        \
-        bgt-    cr7,1f;                                         \
-                                                                \
-        /* get time and PURR snapshots after hcall */           \
-        mftb    r7;                     /* timebase after */    \
-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_IFSET(CPU_FTR_PURR);                            \
-        ld      r5,STK_PARM(r5)(r1);    /* timebase before */   \
-        subf    r5,r5,r7;               /* time delta */        \
-                                                                \
-        /* calculate address of stat structure r4 = opcode */   \
-        srdi    r4,r4,2;                /* index into array */  \
-        mulli   r4,r4,HCALL_STAT_SIZE;                          \
-        LOAD_REG_ADDR(r7, per_cpu__hcall_stats);                \
-        add     r4,r4,r7;                                       \
-        ld      r7,PACA_DATA_OFFSET(r13); /* per cpu offset */  \
-        add     r4,r4,r7;                                       \
-                                                                \
-        /* update stats */                                      \
-        ld      r7,HCALL_STAT_CALLS(r4); /* count */            \
-        addi    r7,r7,1;                                        \
-        std     r7,HCALL_STAT_CALLS(r4);                        \
-        ld      r7,HCALL_STAT_TB(r4);   /* timebase */          \
-        add     r7,r7,r5;                                       \
-        std     r7,HCALL_STAT_TB(r4);                           \
-BEGIN_FTR_SECTION;                                              \
-        ld      r7,HCALL_STAT_PURR(r4); /* PURR */              \
-        add     r7,r7,r6;                                       \
-        std     r7,HCALL_STAT_PURR(r4);                         \
-END_FTR_SECTION_IFSET(CPU_FTR_PURR);                            \
+        ld      r12,hcall_tracepoint_refcount@toc(r2);          \
+        cmpdi   r12,0;                                          \
+        beq+    1f;                                             \
+        mflr    r0;                                             \
+        ld      r6,STK_PARM(r3)(r1);                            \
+        std     r3,STK_PARM(r3)(r1);                            \
+        mr      r4,r3;                                          \
+        mr      r3,r6;                                          \
+        std     r0,16(r1);                                      \
+        stdu    r1,-STACK_FRAME_OVERHEAD(r1);                   \
+        bl      .__trace_hcall_exit;                            \
+        addi    r1,r1,STACK_FRAME_OVERHEAD;                     \
+        ld      r0,16(r1);                                      \
+        ld      r3,STK_PARM(r3)(r1);                            \
+        mtlr    r0;                                             \
 1:
+
+#define HCALL_INST_POSTCALL_NORETS                              \
+        li      r5,0;                                           \
+        __HCALL_INST_POSTCALL
+
+#define HCALL_INST_POSTCALL(BUFREG)                             \
+        mr      r5,BUFREG;                                      \
+        __HCALL_INST_POSTCALL
+
 #else
-#define HCALL_INST_PRECALL
-#define HCALL_INST_POSTCALL
+#define HCALL_INST_PRECALL(FIRST_ARG)
+#define HCALL_INST_POSTCALL_NORETS
+#define HCALL_INST_POSTCALL(BUFREG)
 #endif
 
         .text
@@ -86,11 +112,11 @@ _GLOBAL(plpar_hcall_norets)
         mfcr    r0
         stw     r0,8(r1)
 
-        HCALL_INST_PRECALL
+        HCALL_INST_PRECALL(r4)
 
         HVSC                            /* invoke the hypervisor */
 
-        HCALL_INST_POSTCALL
+        HCALL_INST_POSTCALL_NORETS
 
         lwz     r0,8(r1)
         mtcrf   0xff,r0
@@ -102,7 +128,7 @@ _GLOBAL(plpar_hcall)
         mfcr    r0
         stw     r0,8(r1)
 
-        HCALL_INST_PRECALL
+        HCALL_INST_PRECALL(r5)
 
         std     r4,STK_PARM(r4)(r1)     /* Save ret buffer */
 
@@ -121,7 +147,7 @@ _GLOBAL(plpar_hcall)
         std     r6, 16(r12)
         std     r7, 24(r12)
 
-        HCALL_INST_POSTCALL
+        HCALL_INST_POSTCALL(r12)
 
         lwz     r0,8(r1)
         mtcrf   0xff,r0
@@ -168,7 +194,7 @@ _GLOBAL(plpar_hcall9)
         mfcr    r0
         stw     r0,8(r1)
 
-        HCALL_INST_PRECALL
+        HCALL_INST_PRECALL(r5)
 
         std     r4,STK_PARM(r4)(r1)     /* Save ret buffer */
 
@@ -196,7 +222,7 @@ _GLOBAL(plpar_hcall9)
         std     r11,56(r12)
         std     r0, 64(r12)
 
-        HCALL_INST_POSTCALL
+        HCALL_INST_POSTCALL(r12)
 
         lwz     r0,8(r1)
         mtcrf   0xff,r0
diff --git a/arch/powerpc/platforms/pseries/hvCall_inst.c b/arch/powerpc/platforms/pseries/hvCall_inst.c
index 3631a4f277eb..2f58c71b7259 100644
--- a/arch/powerpc/platforms/pseries/hvCall_inst.c
+++ b/arch/powerpc/platforms/pseries/hvCall_inst.c
@@ -26,6 +26,7 @@
 #include <asm/hvcall.h>
 #include <asm/firmware.h>
 #include <asm/cputable.h>
+#include <asm/trace.h>
 
 DEFINE_PER_CPU(struct hcall_stats[HCALL_STAT_ARRAY_SIZE], hcall_stats);
 
@@ -100,6 +101,35 @@ static const struct file_operations hcall_inst_seq_fops = {
 #define HCALL_ROOT_DIR          "hcall_inst"
 #define CPU_NAME_BUF_SIZE       32
 
+
+static void probe_hcall_entry(unsigned long opcode, unsigned long *args)
+{
+        struct hcall_stats *h;
+
+        if (opcode > MAX_HCALL_OPCODE)
+                return;
+
+        h = &get_cpu_var(hcall_stats)[opcode / 4];
+        h->tb_start = mftb();
+        h->purr_start = mfspr(SPRN_PURR);
+}
+
+static void probe_hcall_exit(unsigned long opcode, unsigned long retval,
+                             unsigned long *retbuf)
+{
+        struct hcall_stats *h;
+
+        if (opcode > MAX_HCALL_OPCODE)
+                return;
+
+        h = &__get_cpu_var(hcall_stats)[opcode / 4];
+        h->num_calls++;
+        h->tb_total = mftb() - h->tb_start;
+        h->purr_total = mfspr(SPRN_PURR) - h->purr_start;
+
+        put_cpu_var(hcall_stats);
+}
+
 static int __init hcall_inst_init(void)
 {
         struct dentry *hcall_root;
@@ -110,6 +140,14 @@ static int __init hcall_inst_init(void)
         if (!firmware_has_feature(FW_FEATURE_LPAR))
                 return 0;
 
+        if (register_trace_hcall_entry(probe_hcall_entry))
+                return -EINVAL;
+
+        if (register_trace_hcall_exit(probe_hcall_exit)) {
+                unregister_trace_hcall_entry(probe_hcall_entry);
+                return -EINVAL;
+        }
+
         hcall_root = debugfs_create_dir(HCALL_ROOT_DIR, NULL);
         if (!hcall_root)
                 return -ENOMEM;
diff --git a/arch/powerpc/platforms/pseries/lpar.c b/arch/powerpc/platforms/pseries/lpar.c
index 903eb9eec687..0707653612ba 100644
--- a/arch/powerpc/platforms/pseries/lpar.c
+++ b/arch/powerpc/platforms/pseries/lpar.c
@@ -39,6 +39,7 @@
 #include <asm/cputable.h>
 #include <asm/udbg.h>
 #include <asm/smp.h>
+#include <asm/trace.h>
 
 #include "plpar_wrappers.h"
 #include "pseries.h"
@@ -661,3 +662,35 @@ void arch_free_page(struct page *page, int order)
 EXPORT_SYMBOL(arch_free_page);
 
 #endif
+
+#ifdef CONFIG_TRACEPOINTS
+/*
+ * We optimise our hcall path by placing hcall_tracepoint_refcount
+ * directly in the TOC so we can check if the hcall tracepoints are
+ * enabled via a single load.
+ */
+
+/* NB: reg/unreg are called while guarded with the tracepoints_mutex */
+extern long hcall_tracepoint_refcount;
+
+void hcall_tracepoint_regfunc(void)
+{
+        hcall_tracepoint_refcount++;
+}
+
+void hcall_tracepoint_unregfunc(void)
+{
+        hcall_tracepoint_refcount--;
+}
+
+void __trace_hcall_entry(unsigned long opcode, unsigned long *args)
+{
+        trace_hcall_entry(opcode, args);
+}
+
+void __trace_hcall_exit(long opcode, unsigned long retval,
+                        unsigned long *retbuf)
+{
+        trace_hcall_exit(opcode, retval, retbuf);
+}
+#endif
diff --git a/arch/powerpc/platforms/pseries/offline_states.h b/arch/powerpc/platforms/pseries/offline_states.h
new file mode 100644
index 000000000000..22574e0d9d91
--- /dev/null
+++ b/arch/powerpc/platforms/pseries/offline_states.h
@@ -0,0 +1,18 @@
+#ifndef _OFFLINE_STATES_H_
+#define _OFFLINE_STATES_H_
+
+/* Cpu offline states go here */
+enum cpu_state_vals {
+        CPU_STATE_OFFLINE,
+        CPU_STATE_INACTIVE,
+        CPU_STATE_ONLINE,
+        CPU_MAX_OFFLINE_STATES
+};
+
+extern enum cpu_state_vals get_cpu_current_state(int cpu);
+extern void set_cpu_current_state(int cpu, enum cpu_state_vals state);
+extern enum cpu_state_vals get_preferred_offline_state(int cpu);
+extern void set_preferred_offline_state(int cpu, enum cpu_state_vals state);
+extern void set_default_offline_state(int cpu);
+extern int start_secondary(void);
+#endif
diff --git a/arch/powerpc/platforms/pseries/plpar_wrappers.h b/arch/powerpc/platforms/pseries/plpar_wrappers.h
index a24a6b2333b2..0603c91538ae 100644
--- a/arch/powerpc/platforms/pseries/plpar_wrappers.h
+++ b/arch/powerpc/platforms/pseries/plpar_wrappers.h
@@ -9,11 +9,33 @@ static inline long poll_pending(void)
         return plpar_hcall_norets(H_POLL_PENDING);
 }
 
+static inline u8 get_cede_latency_hint(void)
+{
+        return get_lppaca()->gpr5_dword.fields.cede_latency_hint;
+}
+
+static inline void set_cede_latency_hint(u8 latency_hint)
+{
+        get_lppaca()->gpr5_dword.fields.cede_latency_hint = latency_hint;
+}
+
 static inline long cede_processor(void)
 {
         return plpar_hcall_norets(H_CEDE);
 }
 
+static inline long extended_cede_processor(unsigned long latency_hint)
+{
+        long rc;
+        u8 old_latency_hint = get_cede_latency_hint();
+
+        set_cede_latency_hint(latency_hint);
+        rc = cede_processor();
+        set_cede_latency_hint(old_latency_hint);
+
+        return rc;
+}
+
 static inline long vpa_call(unsigned long flags, unsigned long cpu,
                 unsigned long vpa)
 {
diff --git a/arch/powerpc/platforms/pseries/reconfig.c b/arch/powerpc/platforms/pseries/reconfig.c
index 2e2bbe120b90..a2305d29bbbd 100644
--- a/arch/powerpc/platforms/pseries/reconfig.c
+++ b/arch/powerpc/platforms/pseries/reconfig.c
@@ -96,7 +96,7 @@ static struct device_node *derive_parent(const char *path)
         return parent;
 }
 
-static BLOCKING_NOTIFIER_HEAD(pSeries_reconfig_chain);
+BLOCKING_NOTIFIER_HEAD(pSeries_reconfig_chain);
 
 int pSeries_reconfig_notifier_register(struct notifier_block *nb)
 {
@@ -184,7 +184,7 @@ static int pSeries_reconfig_remove_node(struct device_node *np)
 }
 
 /*
- * /proc/ppc64/ofdt - yucky binary interface for adding and removing
+ * /proc/powerpc/ofdt - yucky binary interface for adding and removing
  * OF device nodes.  Should be deprecated as soon as we get an
  * in-kernel wrapper for the RTAS ibm,configure-connector call.
  */
@@ -543,7 +543,7 @@ static const struct file_operations ofdt_fops = {
         .write = ofdt_write
 };
 
-/* create /proc/ppc64/ofdt write-only by root */
+/* create /proc/powerpc/ofdt write-only by root */
 static int proc_ppc64_create_ofdt(void)
 {
         struct proc_dir_entry *ent;
@@ -551,7 +551,7 @@ static int proc_ppc64_create_ofdt(void)
         if (!machine_is(pseries))
                 return 0;
 
-        ent = proc_create("ppc64/ofdt", S_IWUSR, NULL, &ofdt_fops);
+        ent = proc_create("powerpc/ofdt", S_IWUSR, NULL, &ofdt_fops);
         if (ent)
                 ent->size = 0;
 
diff --git a/arch/powerpc/platforms/pseries/rtasd.c b/arch/powerpc/platforms/pseries/rtasd.c
deleted file mode 100644
index b3cbac855924..000000000000
--- a/arch/powerpc/platforms/pseries/rtasd.c
+++ /dev/null
@@ -1,519 +0,0 @@
-/*
- * Copyright (C) 2001 Anton Blanchard <anton@au.ibm.com>, IBM
- *
- * 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.
- *
- * Communication to userspace based on kernel/printk.c
- */
-
-#include <linux/types.h>
-#include <linux/errno.h>
-#include <linux/sched.h>
-#include <linux/kernel.h>
-#include <linux/poll.h>
-#include <linux/proc_fs.h>
-#include <linux/init.h>
-#include <linux/vmalloc.h>
-#include <linux/spinlock.h>
-#include <linux/cpu.h>
-#include <linux/workqueue.h>
-
-#include <asm/uaccess.h>
-#include <asm/io.h>
-#include <asm/rtas.h>
-#include <asm/prom.h>
-#include <asm/nvram.h>
-#include <asm/atomic.h>
-#include <asm/machdep.h>
-
-
-static DEFINE_SPINLOCK(rtasd_log_lock);
-
-static DECLARE_WAIT_QUEUE_HEAD(rtas_log_wait);
-
-static char *rtas_log_buf;
-static unsigned long rtas_log_start;
-static unsigned long rtas_log_size;
-
-static int surveillance_timeout = -1;
-static unsigned int rtas_error_log_max;
-static unsigned int rtas_error_log_buffer_max;
-
-/* RTAS service tokens */
-static unsigned int event_scan;
-static unsigned int rtas_event_scan_rate;
-
-static int full_rtas_msgs = 0;
-
-/* Stop logging to nvram after first fatal error */
-static int logging_enabled; /* Until we initialize everything,
-                             * make sure we don't try logging
-                             * anything */
-static int error_log_cnt;
-
-/*
- * Since we use 32 bit RTAS, the physical address of this must be below
- * 4G or else bad things happen. Allocate this in the kernel data and
- * make it big enough.
- */
-static unsigned char logdata[RTAS_ERROR_LOG_MAX];
-
-static char *rtas_type[] = {
-        "Unknown", "Retry", "TCE Error", "Internal Device Failure",
-        "Timeout", "Data Parity", "Address Parity", "Cache Parity",
-        "Address Invalid", "ECC Uncorrected", "ECC Corrupted",
-};
-
-static char *rtas_event_type(int type)
-{
-        if ((type > 0) && (type < 11))
-                return rtas_type[type];
-
-        switch (type) {
-                case RTAS_TYPE_EPOW:
-                        return "EPOW";
-                case RTAS_TYPE_PLATFORM:
-                        return "Platform Error";
-                case RTAS_TYPE_IO:
-                        return "I/O Event";
-                case RTAS_TYPE_INFO:
-                        return "Platform Information Event";
-                case RTAS_TYPE_DEALLOC:
-                        return "Resource Deallocation Event";
-                case RTAS_TYPE_DUMP:
-                        return "Dump Notification Event";
-        }
-
-        return rtas_type[0];
-}
-
-/* To see this info, grep RTAS /var/log/messages and each entry
- * will be collected together with obvious begin/end.
- * There will be a unique identifier on the begin and end lines.
- * This will persist across reboots.
- *
- * format of error logs returned from RTAS:
- * bytes        (size)  : contents
- * --------------------------------------------------------
- * 0-7          (8)     : rtas_error_log
- * 8-47         (40)    : extended info
- * 48-51        (4)     : vendor id
- * 52-1023 (vendor specific) : location code and debug data
- */
-static void printk_log_rtas(char *buf, int len)
-{
-
-        int i,j,n = 0;
-        int perline = 16;
-        char buffer[64];
-        char * str = "RTAS event";
-
-        if (full_rtas_msgs) {
-                printk(RTAS_DEBUG "%d -------- %s begin --------\n",
-                       error_log_cnt, str);
-
-                /*
-                 * Print perline bytes on each line, each line will start
-                 * with RTAS and a changing number, so syslogd will
-                 * print lines that are otherwise the same.  Separate every
-                 * 4 bytes with a space.
-                 */
-                for (i = 0; i < len; i++) {
-                        j = i % perline;
-                        if (j == 0) {
-                                memset(buffer, 0, sizeof(buffer));
-                                n = sprintf(buffer, "RTAS %d:", i/perline);
-                        }
-
-                        if ((i % 4) == 0)
-                                n += sprintf(buffer+n, " ");
-
-                        n += sprintf(buffer+n, "%02x", (unsigned char)buf[i]);
-
-                        if (j == (perline-1))
-                                printk(KERN_DEBUG "%s\n", buffer);
-                }
-                if ((i % perline) != 0)
-                        printk(KERN_DEBUG "%s\n", buffer);
-
-                printk(RTAS_DEBUG "%d -------- %s end ----------\n",
-                       error_log_cnt, str);
-        } else {
-                struct rtas_error_log *errlog = (struct rtas_error_log *)buf;
-
-                printk(RTAS_DEBUG "event: %d, Type: %s, Severity: %d\n",
-                       error_log_cnt, rtas_event_type(errlog->type),
-                       errlog->severity);
-        }
-}
-
-static int log_rtas_len(char * buf)
-{
-        int len;
-        struct rtas_error_log *err;
-
-        /* rtas fixed header */
-        len = 8;
-        err = (struct rtas_error_log *)buf;
-        if (err->extended_log_length) {
-
-                /* extended header */
-                len += err->extended_log_length;
-        }
-
-        if (rtas_error_log_max == 0)
-                rtas_error_log_max = rtas_get_error_log_max();
-
-        if (len > rtas_error_log_max)
-                len = rtas_error_log_max;
-
-        return len;
-}
-
-/*
- * First write to nvram, if fatal error, that is the only
- * place we log the info.  The error will be picked up
- * on the next reboot by rtasd.  If not fatal, run the
- * method for the type of error.  Currently, only RTAS
- * errors have methods implemented, but in the future
- * there might be a need to store data in nvram before a
- * call to panic().
- *
- * XXX We write to nvram periodically, to indicate error has
- * been written and sync'd, but there is a possibility
- * that if we don't shutdown correctly, a duplicate error
- * record will be created on next reboot.
- */
-void pSeries_log_error(char *buf, unsigned int err_type, int fatal)
-{
-        unsigned long offset;
-        unsigned long s;
-        int len = 0;
-
-        pr_debug("rtasd: logging event\n");
-        if (buf == NULL)
-                return;
-
-        spin_lock_irqsave(&rtasd_log_lock, s);
-
-        /* get length and increase count */
-        switch (err_type & ERR_TYPE_MASK) {
-        case ERR_TYPE_RTAS_LOG:
-                len = log_rtas_len(buf);
-                if (!(err_type & ERR_FLAG_BOOT))
-                        error_log_cnt++;
-                break;
-        case ERR_TYPE_KERNEL_PANIC:
-        default:
-                WARN_ON_ONCE(!irqs_disabled()); /* @@@ DEBUG @@@ */
-                spin_unlock_irqrestore(&rtasd_log_lock, s);
-                return;
-        }
-
-        /* Write error to NVRAM */
-        if (logging_enabled && !(err_type & ERR_FLAG_BOOT))
-                nvram_write_error_log(buf, len, err_type, error_log_cnt);
-
-        /*
-         * rtas errors can occur during boot, and we do want to capture
-         * those somewhere, even if nvram isn't ready (why not?), and even
-         * if rtasd isn't ready. Put them into the boot log, at least.
-         */
-        if ((err_type & ERR_TYPE_MASK) == ERR_TYPE_RTAS_LOG)
-                printk_log_rtas(buf, len);
-
-        /* Check to see if we need to or have stopped logging */
-        if (fatal || !logging_enabled) {
-                logging_enabled = 0;
-                WARN_ON_ONCE(!irqs_disabled()); /* @@@ DEBUG @@@ */
-                spin_unlock_irqrestore(&rtasd_log_lock, s);
-                return;
-        }
-
-        /* call type specific method for error */
-        switch (err_type & ERR_TYPE_MASK) {
-        case ERR_TYPE_RTAS_LOG:
-                offset = rtas_error_log_buffer_max *
-                        ((rtas_log_start+rtas_log_size) & LOG_NUMBER_MASK);
-
-                /* First copy over sequence number */
-                memcpy(&rtas_log_buf[offset], (void *) &error_log_cnt, sizeof(int));
-
-                /* Second copy over error log data */
-                offset += sizeof(int);
-                memcpy(&rtas_log_buf[offset], buf, len);
-
-                if (rtas_log_size < LOG_NUMBER)
-                        rtas_log_size += 1;
-                else
-                        rtas_log_start += 1;
-
-                WARN_ON_ONCE(!irqs_disabled()); /* @@@ DEBUG @@@ */
-                spin_unlock_irqrestore(&rtasd_log_lock, s);
-                wake_up_interruptible(&rtas_log_wait);
-                break;
-        case ERR_TYPE_KERNEL_PANIC:
-        default:
-                WARN_ON_ONCE(!irqs_disabled()); /* @@@ DEBUG @@@ */
-                spin_unlock_irqrestore(&rtasd_log_lock, s);
-                return;
-        }
-
-}
-
-
-static int rtas_log_open(struct inode * inode, struct file * file)
-{
-        return 0;
-}
-
-static int rtas_log_release(struct inode * inode, struct file * file)
-{
-        return 0;
-}
-
-/* This will check if all events are logged, if they are then, we
- * know that we can safely clear the events in NVRAM.
- * Next we'll sit and wait for something else to log.
- */
-static ssize_t rtas_log_read(struct file * file, char __user * buf,
-                         size_t count, loff_t *ppos)
-{
-        int error;
-        char *tmp;
-        unsigned long s;
-        unsigned long offset;
-
-        if (!buf || count < rtas_error_log_buffer_max)
-                return -EINVAL;
-
-        count = rtas_error_log_buffer_max;
-
-        if (!access_ok(VERIFY_WRITE, buf, count))
-                return -EFAULT;
-
-        tmp = kmalloc(count, GFP_KERNEL);
-        if (!tmp)
-                return -ENOMEM;
-
-        spin_lock_irqsave(&rtasd_log_lock, s);
-        /* if it's 0, then we know we got the last one (the one in NVRAM) */
-        while (rtas_log_size == 0) {
-                if (file->f_flags & O_NONBLOCK) {
-                        spin_unlock_irqrestore(&rtasd_log_lock, s);
-                        error = -EAGAIN;
-                        goto out;
-                }
-
-                if (!logging_enabled) {
-                        spin_unlock_irqrestore(&rtasd_log_lock, s);
-                        error = -ENODATA;
-                        goto out;
-                }
-                nvram_clear_error_log();
-
-                spin_unlock_irqrestore(&rtasd_log_lock, s);
-                error = wait_event_interruptible(rtas_log_wait, rtas_log_size);
-                if (error)
-                        goto out;
-                spin_lock_irqsave(&rtasd_log_lock, s);
-        }
-
-        offset = rtas_error_log_buffer_max * (rtas_log_start & LOG_NUMBER_MASK);
-        memcpy(tmp, &rtas_log_buf[offset], count);
-
-        rtas_log_start += 1;
-        rtas_log_size -= 1;
-        spin_unlock_irqrestore(&rtasd_log_lock, s);
-
-        error = copy_to_user(buf, tmp, count) ? -EFAULT : count;
-out:
-        kfree(tmp);
-        return error;
-}
-
-static unsigned int rtas_log_poll(struct file *file, poll_table * wait)
-{
-        poll_wait(file, &rtas_log_wait, wait);
-        if (rtas_log_size)
-                return POLLIN | POLLRDNORM;
-        return 0;
-}
-
-static const struct file_operations proc_rtas_log_operations = {
-        .read =         rtas_log_read,
-        .poll =         rtas_log_poll,
-        .open =         rtas_log_open,
-        .release =      rtas_log_release,
-};
-
-static int enable_surveillance(int timeout)
-{
-        int error;
-
-        error = rtas_set_indicator(SURVEILLANCE_TOKEN, 0, timeout);
-
-        if (error == 0)
-                return 0;
-
-        if (error == -EINVAL) {
-                printk(KERN_DEBUG "rtasd: surveillance not supported\n");
-                return 0;
-        }
-
-        printk(KERN_ERR "rtasd: could not update surveillance\n");
-        return -1;
-}
-
-static void do_event_scan(void)
-{
-        int error;
-        do {
-                memset(logdata, 0, rtas_error_log_max);
-                error = rtas_call(event_scan, 4, 1, NULL,
-                                  RTAS_EVENT_SCAN_ALL_EVENTS, 0,
-                                  __pa(logdata), rtas_error_log_max);
-                if (error == -1) {
-                        printk(KERN_ERR "event-scan failed\n");
-                        break;
-                }
-
-                if (error == 0)
-                        pSeries_log_error(logdata, ERR_TYPE_RTAS_LOG, 0);
-
-        } while(error == 0);
-}
-
-static void rtas_event_scan(struct work_struct *w);
-DECLARE_DELAYED_WORK(event_scan_work, rtas_event_scan);
-
-/*
- * Delay should be at least one second since some machines have problems if
- * we call event-scan too quickly.
- */
-static unsigned long event_scan_delay = 1*HZ;
-static int first_pass = 1;
-
-static void rtas_event_scan(struct work_struct *w)
-{
-        unsigned int cpu;
-
-        do_event_scan();
-
-        get_online_cpus();
-
-        cpu = next_cpu(smp_processor_id(), cpu_online_map);
-        if (cpu == NR_CPUS) {
-                cpu = first_cpu(cpu_online_map);
-
-                if (first_pass) {
-                        first_pass = 0;
-                        event_scan_delay = 30*HZ/rtas_event_scan_rate;
-
-                        if (surveillance_timeout != -1) {
-                                pr_debug("rtasd: enabling surveillance\n");
-                                enable_surveillance(surveillance_timeout);
-                                pr_debug("rtasd: surveillance enabled\n");
-                        }
-                }
-        }
-
-        schedule_delayed_work_on(cpu, &event_scan_work,
-                __round_jiffies_relative(event_scan_delay, cpu));
-
-        put_online_cpus();
-}
-
-static void start_event_scan(void)
-{
-        unsigned int err_type;
-        int rc;
-
-        printk(KERN_DEBUG "RTAS daemon started\n");
-        pr_debug("rtasd: will sleep for %d milliseconds\n",
-                 (30000 / rtas_event_scan_rate));
-
-        /* See if we have any error stored in NVRAM */
-        memset(logdata, 0, rtas_error_log_max);
-        rc = nvram_read_error_log(logdata, rtas_error_log_max,
-                                  &err_type, &error_log_cnt);
-        /* We can use rtas_log_buf now */
-        logging_enabled = 1;
-
-        if (!rc) {
-                if (err_type != ERR_FLAG_ALREADY_LOGGED) {
-                        pSeries_log_error(logdata, err_type | ERR_FLAG_BOOT, 0);
-                }
-        }
-
-        schedule_delayed_work_on(first_cpu(cpu_online_map), &event_scan_work,
-                                 event_scan_delay);
-}
-
-static int __init rtas_init(void)
-{
-        struct proc_dir_entry *entry;
-
-        if (!machine_is(pseries))
-                return 0;
-
-        /* No RTAS */
-        event_scan = rtas_token("event-scan");
-        if (event_scan == RTAS_UNKNOWN_SERVICE) {
-                printk(KERN_DEBUG "rtasd: no event-scan on system\n");
-                return -ENODEV;
-        }
-
-        rtas_event_scan_rate = rtas_token("rtas-event-scan-rate");
-        if (rtas_event_scan_rate == RTAS_UNKNOWN_SERVICE) {
-                printk(KERN_ERR "rtasd: no rtas-event-scan-rate on system\n");
-                return -ENODEV;
-        }
-
-        /* Make room for the sequence number */
-        rtas_error_log_max = rtas_get_error_log_max();
-        rtas_error_log_buffer_max = rtas_error_log_max + sizeof(int);
-
-        rtas_log_buf = vmalloc(rtas_error_log_buffer_max*LOG_NUMBER);
-        if (!rtas_log_buf) {
-                printk(KERN_ERR "rtasd: no memory\n");
-                return -ENOMEM;
-        }
-
-        entry = proc_create("ppc64/rtas/error_log", S_IRUSR, NULL,
-                            &proc_rtas_log_operations);
-        if (!entry)
-                printk(KERN_ERR "Failed to create error_log proc entry\n");
-
-        start_event_scan();
-
-        return 0;
-}
-
-static int __init surveillance_setup(char *str)
-{
-        int i;
-
-        if (get_option(&str,&i)) {
-                if (i >= 0 && i <= 255)
-                        surveillance_timeout = i;
-        }
-
-        return 1;
-}
-
-static int __init rtasmsgs_setup(char *str)
-{
-        if (strcmp(str, "on") == 0)
-                full_rtas_msgs = 1;
-        else if (strcmp(str, "off") == 0)
-                full_rtas_msgs = 0;
-
-        return 1;
-}
-__initcall(rtas_init);
-__setup("surveillance=", surveillance_setup);
-__setup("rtasmsgs=", rtasmsgs_setup);
diff --git a/arch/powerpc/platforms/pseries/scanlog.c b/arch/powerpc/platforms/pseries/scanlog.c
index 417eca79df69..1b45c458f952 100644
--- a/arch/powerpc/platforms/pseries/scanlog.c
+++ b/arch/powerpc/platforms/pseries/scanlog.c
@@ -13,7 +13,7 @@
  * of this data using this driver.  A dump exists if the device-tree
  * /chosen/ibm,scan-log-data property exists.
  *
- * This driver exports /proc/ppc64/scan-log-dump which can be read.
+ * This driver exports /proc/powerpc/scan-log-dump which can be read.
  * The driver supports only sequential reads.
  *
  * The driver looks at a write to the driver for the single word "reset".
@@ -186,7 +186,7 @@ static int __init scanlog_init(void)
         if (!data)
                 goto err;
 
-        ent = proc_create_data("ppc64/rtas/scan-log-dump", S_IRUSR, NULL,
+        ent = proc_create_data("powerpc/rtas/scan-log-dump", S_IRUSR, NULL,
                                &scanlog_fops, data);
         if (!ent)
                 goto err;
diff --git a/arch/powerpc/platforms/pseries/smp.c b/arch/powerpc/platforms/pseries/smp.c
index 440000cc7130..b4886635972c 100644
--- a/arch/powerpc/platforms/pseries/smp.c
+++ b/arch/powerpc/platforms/pseries/smp.c
@@ -48,6 +48,7 @@
 #include "plpar_wrappers.h"
 #include "pseries.h"
 #include "xics.h"
+#include "offline_states.h"
 
 
 /*
@@ -84,6 +85,9 @@ static inline int __devinit smp_startup_cpu(unsigned int lcpu)
         /* Fixup atomic count: it exited inside IRQ handler. */
         task_thread_info(paca[lcpu].__current)->preempt_count   = 0;
 
+        if (get_cpu_current_state(lcpu) == CPU_STATE_INACTIVE)
+                goto out;
+
         /* 
          * If the RTAS start-cpu token does not exist then presume the
          * cpu is already spinning.
@@ -98,6 +102,7 @@ static inline int __devinit smp_startup_cpu(unsigned int lcpu)
                 return 0;
         }
 
+out:
         return 1;
 }
 
@@ -111,12 +116,16 @@ static void __devinit smp_xics_setup_cpu(int cpu)
                 vpa_init(cpu);
 
         cpu_clear(cpu, of_spin_map);
+        set_cpu_current_state(cpu, CPU_STATE_ONLINE);
+        set_default_offline_state(cpu);
 
 }
 #endif /* CONFIG_XICS */
 
 static void __devinit smp_pSeries_kick_cpu(int nr)
 {
+        long rc;
+        unsigned long hcpuid;
         BUG_ON(nr < 0 || nr >= NR_CPUS);
 
         if (!smp_startup_cpu(nr))
@@ -128,6 +137,16 @@ static void __devinit smp_pSeries_kick_cpu(int nr)
          * the processor will continue on to secondary_start
          */
         paca[nr].cpu_start = 1;
+
+        set_preferred_offline_state(nr, CPU_STATE_ONLINE);
+
+        if (get_cpu_current_state(nr) == CPU_STATE_INACTIVE) {
+                hcpuid = get_hard_smp_processor_id(nr);
+                rc = plpar_hcall_norets(H_PROD, hcpuid);
+                if (rc != H_SUCCESS)
+                        printk(KERN_ERR "Error: Prod to wake up processor %d\
+                                                Ret= %ld\n", nr, rc);
+        }
 }
 
 static int smp_pSeries_cpu_bootable(unsigned int nr)
diff --git a/arch/powerpc/platforms/pseries/xics.c b/arch/powerpc/platforms/pseries/xics.c
index b9bf0eedccf2..d80f193cd871 100644
--- a/arch/powerpc/platforms/pseries/xics.c
+++ b/arch/powerpc/platforms/pseries/xics.c
@@ -20,6 +20,7 @@
 #include <linux/cpu.h>
 #include <linux/msi.h>
 #include <linux/of.h>
+#include <linux/percpu.h>
 
 #include <asm/firmware.h>
 #include <asm/io.h>
@@ -46,6 +47,12 @@ static struct irq_host *xics_host;
  */
 #define IPI_PRIORITY            4
 
+/* The least favored priority */
+#define LOWEST_PRIORITY         0xFF
+
+/* The number of priorities defined above */
+#define MAX_NUM_PRIORITIES      3
+
 static unsigned int default_server = 0xFF;
 static unsigned int default_distrib_server = 0;
 static unsigned int interrupt_server_size = 8;
@@ -56,6 +63,12 @@ static int ibm_set_xive;
 static int ibm_int_on;
 static int ibm_int_off;
 
+struct xics_cppr {
+        unsigned char stack[MAX_NUM_PRIORITIES];
+        int index;
+};
+
+static DEFINE_PER_CPU(struct xics_cppr, xics_cppr);
 
 /* Direct hardware low level accessors */
 
@@ -150,14 +163,13 @@ static inline void lpar_qirr_info(int n_cpu , u8 value)
 /* Interface to generic irq subsystem */
 
 #ifdef CONFIG_SMP
-static int get_irq_server(unsigned int virq, unsigned int strict_check)
+static int get_irq_server(unsigned int virq, cpumask_t cpumask,
+                          unsigned int strict_check)
 {
         int server;
         /* For the moment only implement delivery to all cpus or one cpu */
-        cpumask_t cpumask;
         cpumask_t tmp = CPU_MASK_NONE;
 
-        cpumask_copy(&cpumask, irq_desc[virq].affinity);
         if (!distribute_irqs)
                 return default_server;
 
@@ -179,7 +191,8 @@ static int get_irq_server(unsigned int virq, unsigned int strict_check)
         return default_server;
 }
 #else
-static int get_irq_server(unsigned int virq, unsigned int strict_check)
+static int get_irq_server(unsigned int virq, cpumask_t cpumask,
+                          unsigned int strict_check)
 {
         return default_server;
 }
@@ -198,7 +211,7 @@ static void xics_unmask_irq(unsigned int virq)
         if (irq == XICS_IPI || irq == XICS_IRQ_SPURIOUS)
                 return;
 
-        server = get_irq_server(virq, 0);
+        server = get_irq_server(virq, *(irq_to_desc(virq)->affinity), 0);
 
         call_status = rtas_call(ibm_set_xive, 3, 1, NULL, irq, server,
                                 DEFAULT_PRIORITY);
@@ -284,6 +297,19 @@ static inline unsigned int xics_xirr_vector(unsigned int xirr)
         return xirr & 0x00ffffff;
 }
 
+static void push_cppr(unsigned int vec)
+{
+        struct xics_cppr *os_cppr = &__get_cpu_var(xics_cppr);
+
+        if (WARN_ON(os_cppr->index >= MAX_NUM_PRIORITIES - 1))
+                return;
+
+        if (vec == XICS_IPI)
+                os_cppr->stack[++os_cppr->index] = IPI_PRIORITY;
+        else
+                os_cppr->stack[++os_cppr->index] = DEFAULT_PRIORITY;
+}
+
 static unsigned int xics_get_irq_direct(void)
 {
         unsigned int xirr = direct_xirr_info_get();
@@ -294,8 +320,10 @@ static unsigned int xics_get_irq_direct(void)
                 return NO_IRQ;
 
         irq = irq_radix_revmap_lookup(xics_host, vec);
-        if (likely(irq != NO_IRQ))
+        if (likely(irq != NO_IRQ)) {
+                push_cppr(vec);
                 return irq;
+        }
 
         /* We don't have a linux mapping, so have rtas mask it. */
         xics_mask_unknown_vec(vec);
@@ -315,8 +343,10 @@ static unsigned int xics_get_irq_lpar(void)
                 return NO_IRQ;
 
         irq = irq_radix_revmap_lookup(xics_host, vec);
-        if (likely(irq != NO_IRQ))
+        if (likely(irq != NO_IRQ)) {
+                push_cppr(vec);
                 return irq;
+        }
 
         /* We don't have a linux mapping, so have RTAS mask it. */
         xics_mask_unknown_vec(vec);
@@ -326,12 +356,22 @@ static unsigned int xics_get_irq_lpar(void)
         return NO_IRQ;
 }
 
+static unsigned char pop_cppr(void)
+{
+        struct xics_cppr *os_cppr = &__get_cpu_var(xics_cppr);
+
+        if (WARN_ON(os_cppr->index < 1))
+                return LOWEST_PRIORITY;
+
+        return os_cppr->stack[--os_cppr->index];
+}
+
 static void xics_eoi_direct(unsigned int virq)
 {
         unsigned int irq = (unsigned int)irq_map[virq].hwirq;
 
         iosync();
-        direct_xirr_info_set((0xff << 24) | irq);
+        direct_xirr_info_set((pop_cppr() << 24) | irq);
 }
 
 static void xics_eoi_lpar(unsigned int virq)
@@ -339,7 +379,7 @@ static void xics_eoi_lpar(unsigned int virq)
         unsigned int irq = (unsigned int)irq_map[virq].hwirq;
 
         iosync();
-        lpar_xirr_info_set((0xff << 24) | irq);
+        lpar_xirr_info_set((pop_cppr() << 24) | irq);
 }
 
 static int xics_set_affinity(unsigned int virq, const struct cpumask *cpumask)
@@ -365,7 +405,7 @@ static int xics_set_affinity(unsigned int virq, const struct cpumask *cpumask)
          * For the moment only implement delivery to all cpus or one cpu.
          * Get current irq_server for the given irq
          */
-        irq_server = get_irq_server(virq, 1);
+        irq_server = get_irq_server(virq, *cpumask, 1);
         if (irq_server == -1) {
                 char cpulist[128];
                 cpumask_scnprintf(cpulist, sizeof(cpulist), cpumask);
@@ -388,7 +428,7 @@ static int xics_set_affinity(unsigned int virq, const struct cpumask *cpumask)
 }
 
 static struct irq_chip xics_pic_direct = {
-        .typename = " XICS     ",
+        .name = " XICS     ",
         .startup = xics_startup,
         .mask = xics_mask_irq,
         .unmask = xics_unmask_irq,
@@ -397,7 +437,7 @@ static struct irq_chip xics_pic_direct = {
 };
 
 static struct irq_chip xics_pic_lpar = {
-        .typename = " XICS     ",
+        .name = " XICS     ",
         .startup = xics_startup,
         .mask = xics_mask_irq,
         .unmask = xics_unmask_irq,
@@ -428,13 +468,13 @@ static int xics_host_map(struct irq_host *h, unsigned int virq,
         /* Insert the interrupt mapping into the radix tree for fast lookup */
         irq_radix_revmap_insert(xics_host, virq, hw);
 
-        get_irq_desc(virq)->status |= IRQ_LEVEL;
+        irq_to_desc(virq)->status |= IRQ_LEVEL;
         set_irq_chip_and_handler(virq, xics_irq_chip, handle_fasteoi_irq);
         return 0;
 }
 
 static int xics_host_xlate(struct irq_host *h, struct device_node *ct,
-                           u32 *intspec, unsigned int intsize,
+                           const u32 *intspec, unsigned int intsize,
                            irq_hw_number_t *out_hwirq, unsigned int *out_flags)
 
 {
@@ -746,6 +786,12 @@ void __init xics_init_IRQ(void)
 
 static void xics_set_cpu_priority(unsigned char cppr)
 {
+        struct xics_cppr *os_cppr = &__get_cpu_var(xics_cppr);
+
+        BUG_ON(os_cppr->index != 0);
+
+        os_cppr->stack[os_cppr->index] = cppr;
+
         if (firmware_has_feature(FW_FEATURE_LPAR))
                 lpar_cppr_info(cppr);
         else
@@ -772,7 +818,7 @@ static void xics_set_cpu_giq(unsigned int gserver, unsigned int join)
 
 void xics_setup_cpu(void)
 {
-        xics_set_cpu_priority(0xff);
+        xics_set_cpu_priority(LOWEST_PRIORITY);
 
         xics_set_cpu_giq(default_distrib_server, 1);
 }
@@ -852,7 +898,7 @@ void xics_migrate_irqs_away(void)
                 /* We need to get IPIs still. */
                 if (irq == XICS_IPI || irq == XICS_IRQ_SPURIOUS)
                         continue;
-                desc = get_irq_desc(virq);
+                desc = irq_to_desc(virq);
 
                 /* We only need to migrate enabled IRQS */
                 if (desc == NULL || desc->chip == NULL
@@ -860,7 +906,7 @@ void xics_migrate_irqs_away(void)
                     || desc->chip->set_affinity == NULL)
                         continue;
 
-                spin_lock_irqsave(&desc->lock, flags);
+                raw_spin_lock_irqsave(&desc->lock, flags);
 
                 status = rtas_call(ibm_get_xive, 1, 3, xics_status, irq);
                 if (status) {
@@ -881,10 +927,10 @@ void xics_migrate_irqs_away(void)
                        virq, cpu);
 
                 /* Reset affinity to all cpus */
-                cpumask_setall(irq_desc[virq].affinity);
+                cpumask_setall(irq_to_desc(virq)->affinity);
                 desc->chip->set_affinity(virq, cpu_all_mask);
 unlock:
-                spin_unlock_irqrestore(&desc->lock, flags);
+                raw_spin_unlock_irqrestore(&desc->lock, flags);
         }
 }
 #endif