Merge branch 'next' of git://git.kernel.org/pub/scm/linux/kernel/git/benh/powerpc

* 'next' of git://git.kernel.org/pub/scm/linux/kernel/git/benh/powerpc: (151 commits)
  powerpc: Fix usage of 64-bit instruction in 32-bit altivec code
  MAINTAINERS: Add PowerPC patterns
  powerpc/pseries: Track previous CPPR values to correctly EOI interrupts
  powerpc/pseries: Correct pseries/dlpar.c build break without CONFIG_SMP
  powerpc: Make "intspec" pointers in irq_host->xlate() const
  powerpc/8xx: DTLB Miss cleanup
  powerpc/8xx: Remove DIRTY pte handling in DTLB Error.
  powerpc/8xx: Start using dcbX instructions in various copy routines
  powerpc/8xx: Restore _PAGE_WRITETHRU
  powerpc/8xx: Add missing Guarded setting in DTLB Error.
  powerpc/8xx: Fixup DAR from buggy dcbX instructions.
  powerpc/8xx: Tag DAR with 0x00f0 to catch buggy instructions.
  powerpc/8xx: Update TLB asm so it behaves as linux mm expects.
  powerpc/8xx: Invalidate non present TLBs
  powerpc/pseries: Serialize cpu hotplug operations during deactivate Vs deallocate
  pseries/pseries: Add code to online/offline CPUs of a DLPAR node
  powerpc: stop_this_cpu: remove the cpu from the online map.
  powerpc/pseries: Add kernel based CPU DLPAR handling
  sysfs/cpu: Add probe/release files
  powerpc/pseries: Kernel DLPAR Infrastructure
  ...

53 files changed, 2261 insertions, 708 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/media5200.c b/arch/powerpc/platforms/52xx/media5200.c
index 68e4f1696d14..cc0c854291d7 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,
@@ -114,7 +114,7 @@ void media5200_irq_cascade(unsigned int virq, struct irq_desc *desc)
 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_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..d306f07b9aa1 100644
--- a/arch/powerpc/platforms/83xx/suspend.c
+++ b/arch/powerpc/platforms/83xx/suspend.c
@@ -96,6 +96,7 @@ int fsl_deep_sleep(void)
 {
         return deep_sleeping;
 }
+EXPORT_SYMBOL(fsl_deep_sleep);
 
 static int mpc83xx_change_state(void)
 {
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..c5028a2e5a58 100644
--- a/arch/powerpc/platforms/85xx/mpc85xx_mds.c
+++ b/arch/powerpc/platforms/85xx/mpc85xx_mds.c
@@ -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..2eab27a94cc9 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
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/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..f9dbf76a763f 100644
--- a/arch/powerpc/platforms/cell/interrupt.c
+++ b/arch/powerpc/platforms/cell/interrupt.c
@@ -88,7 +88,7 @@ static void iic_eoi(unsigned int irq)
 }
 
 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,
@@ -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)
 
 {
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/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..52f3df3b4ca0 100644
--- a/arch/powerpc/platforms/chrp/setup.c
+++ b/arch/powerpc/platforms/chrp/setup.c
@@ -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/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..07762259c60a 100644
--- a/arch/powerpc/platforms/iseries/irq.c
+++ b/arch/powerpc/platforms/iseries/irq.c
@@ -214,7 +214,7 @@ 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);
@@ -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/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..27554c807fd5 100644
--- a/arch/powerpc/platforms/pseries/Kconfig
+++ b/arch/powerpc/platforms/pseries/Kconfig
@@ -4,6 +4,7 @@ config PPC_PSERIES
         select MPIC
         select PPC_I8259
         select PPC_RTAS
+        select PPC_RTAS_DAEMON
         select RTAS_ERROR_LOGGING
         select PPC_UDBG_16550
         select PPC_NATIVE
@@ -59,7 +60,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..bcdcf0ccc8d7 100644
--- a/arch/powerpc/platforms/pseries/cmm.c
+++ b/arch/powerpc/platforms/pseries/cmm.c
@@ -229,8 +229,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 +239,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;
+
+        if (min_mem_pages > active_pages_target)
+                target = total_pages - min_mem_pages;
 
-        active_pages_target = totalram_pages + loaned_pages - loaned_pages_target;
+        if (target < 0)
+                target = 0;
 
-        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);
+        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,
diff --git a/arch/powerpc/platforms/pseries/dlpar.c b/arch/powerpc/platforms/pseries/dlpar.c
new file mode 100644
index 000000000000..12df9e8812a9
--- /dev/null
+++ b/arch/powerpc/platforms/pseries/dlpar.c
@@ -0,0 +1,558 @@
+/*
+ * 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)
+{
+        struct proc_dir_entry *ent;
+        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)
+{
+        struct device_node *parent = dn->parent;
+        struct property *prop = dn->properties;
+
+#ifdef CONFIG_PROC_DEVICETREE
+        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 DEFINE_MUTEX(pseries_cpu_hotplug_mutex);
+
+void cpu_hotplug_driver_lock()
+{
+        mutex_lock(&pseries_cpu_hotplug_mutex);
+}
+
+void cpu_hotplug_driver_unlock()
+{
+        mutex_unlock(&pseries_cpu_hotplug_mutex);
+}
+
+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/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/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..8868c012268a 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)
+                        panic("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..7d01b58f3989 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 */
 
@@ -157,7 +170,7 @@ static int get_irq_server(unsigned int virq, unsigned int strict_check)
         cpumask_t cpumask;
         cpumask_t tmp = CPU_MASK_NONE;
 
-        cpumask_copy(&cpumask, irq_desc[virq].affinity);
+        cpumask_copy(&cpumask, irq_to_desc(virq)->affinity);
         if (!distribute_irqs)
                 return default_server;
 
@@ -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)
@@ -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
@@ -881,7 +927,7 @@ 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);