8 files changed, 623 insertions, 71 deletions

diff --git a/arch/powerpc/platforms/pseries/Makefile b/arch/powerpc/platforms/pseries/Makefile
index 046ace9c438..59eb8bdaa79 100644
--- a/arch/powerpc/platforms/pseries/Makefile
+++ b/arch/powerpc/platforms/pseries/Makefile
@@ -1,14 +1,9 @@
-ifeq ($(CONFIG_PPC64),y)
-EXTRA_CFLAGS            += -mno-minimal-toc
-endif
-
-ifeq ($(CONFIG_PPC_PSERIES_DEBUG),y)
-EXTRA_CFLAGS            += -DDEBUG
-endif
+ccflags-$(CONFIG_PPC64)                 := -mno-minimal-toc
+ccflags-$(CONFIG_PPC_PSERIES_DEBUG)     += -DDEBUG
 
 obj-y                   := lpar.o hvCall.o nvram.o reconfig.o \
                            setup.o iommu.o event_sources.o ras.o \
-                           firmware.o power.o dlpar.o
+                           firmware.o power.o dlpar.o mobility.o
 obj-$(CONFIG_SMP)       += smp.o
 obj-$(CONFIG_XICS)      += xics.o
 obj-$(CONFIG_SCANLOG)   += scanlog.o
@@ -23,7 +18,7 @@ obj-$(CONFIG_MEMORY_HOTPLUG)	+= hotplug-memory.o
 obj-$(CONFIG_HVC_CONSOLE)       += hvconsole.o
 obj-$(CONFIG_HVCS)              += hvcserver.o
 obj-$(CONFIG_HCALL_STATS)       += hvCall_inst.o
-obj-$(CONFIG_PHYP_DUMP) += phyp_dump.o
+obj-$(CONFIG_PHYP_DUMP)         += phyp_dump.o
 obj-$(CONFIG_CMM)               += cmm.o
 obj-$(CONFIG_DTL)               += dtl.o
 
diff --git a/arch/powerpc/platforms/pseries/dlpar.c b/arch/powerpc/platforms/pseries/dlpar.c
index 72d8054fa73..b74a9230edc 100644
--- a/arch/powerpc/platforms/pseries/dlpar.c
+++ b/arch/powerpc/platforms/pseries/dlpar.c
@@ -33,7 +33,7 @@ struct cc_workarea {
         u32     prop_offset;
 };
 
-static void dlpar_free_cc_property(struct property *prop)
+void dlpar_free_cc_property(struct property *prop)
 {
         kfree(prop->name);
         kfree(prop->value);
@@ -55,13 +55,12 @@ static struct property *dlpar_parse_cc_property(struct cc_workarea *ccwa)
 
         prop->length = ccwa->prop_length;
         value = (char *)ccwa + ccwa->prop_offset;
-        prop->value = kzalloc(prop->length, GFP_KERNEL);
+        prop->value = kmemdup(value, prop->length, GFP_KERNEL);
         if (!prop->value) {
                 dlpar_free_cc_property(prop);
                 return NULL;
         }
 
-        memcpy(prop->value, value, prop->length);
         return prop;
 }
 
@@ -102,7 +101,7 @@ static void dlpar_free_one_cc_node(struct device_node *dn)
         kfree(dn);
 }
 
-static void dlpar_free_cc_nodes(struct device_node *dn)
+void dlpar_free_cc_nodes(struct device_node *dn)
 {
         if (dn->child)
                 dlpar_free_cc_nodes(dn->child);
diff --git a/arch/powerpc/platforms/pseries/dtl.c b/arch/powerpc/platforms/pseries/dtl.c
index a00addb5594..c371bc06434 100644
--- a/arch/powerpc/platforms/pseries/dtl.c
+++ b/arch/powerpc/platforms/pseries/dtl.c
@@ -23,37 +23,22 @@
 #include <linux/init.h>
 #include <linux/slab.h>
 #include <linux/debugfs.h>
+#include <linux/spinlock.h>
 #include <asm/smp.h>
 #include <asm/system.h>
 #include <asm/uaccess.h>
 #include <asm/firmware.h>
+#include <asm/lppaca.h>
 
 #include "plpar_wrappers.h"
 
-/*
- * Layout of entries in the hypervisor's DTL buffer. Although we don't
- * actually access the internals of an entry (we only need to know the size),
- * we might as well define it here for reference.
- */
-struct dtl_entry {
-        u8      dispatch_reason;
-        u8      preempt_reason;
-        u16     processor_id;
-        u32     enqueue_to_dispatch_time;
-        u32     ready_to_enqueue_time;
-        u32     waiting_to_ready_time;
-        u64     timebase;
-        u64     fault_addr;
-        u64     srr0;
-        u64     srr1;
-};
-
 struct dtl {
         struct dtl_entry        *buf;
         struct dentry           *file;
         int                     cpu;
         int                     buf_entries;
         u64                     last_idx;
+        spinlock_t              lock;
 };
 static DEFINE_PER_CPU(struct dtl, cpu_dtl);
 
@@ -72,25 +57,97 @@ static u8 dtl_event_mask = 0x7;
 static int dtl_buf_entries = (16 * 85);
 
 
-static int dtl_enable(struct dtl *dtl)
+#ifdef CONFIG_VIRT_CPU_ACCOUNTING
+struct dtl_ring {
+        u64     write_index;
+        struct dtl_entry *write_ptr;
+        struct dtl_entry *buf;
+        struct dtl_entry *buf_end;
+        u8      saved_dtl_mask;
+};
+
+static DEFINE_PER_CPU(struct dtl_ring, dtl_rings);
+
+static atomic_t dtl_count;
+
+/*
+ * The cpu accounting code controls the DTL ring buffer, and we get
+ * given entries as they are processed.
+ */
+static void consume_dtle(struct dtl_entry *dtle, u64 index)
 {
-        unsigned long addr;
-        int ret, hwcpu;
+        struct dtl_ring *dtlr = &__get_cpu_var(dtl_rings);
+        struct dtl_entry *wp = dtlr->write_ptr;
+        struct lppaca *vpa = local_paca->lppaca_ptr;
 
-        /* only allow one reader */
-        if (dtl->buf)
-                return -EBUSY;
+        if (!wp)
+                return;
 
-        /* we need to store the original allocation size for use during read */
-        dtl->buf_entries = dtl_buf_entries;
+        *wp = *dtle;
+        barrier();
 
-        dtl->buf = kmalloc_node(dtl->buf_entries * sizeof(struct dtl_entry),
-                        GFP_KERNEL, cpu_to_node(dtl->cpu));
-        if (!dtl->buf) {
-                printk(KERN_WARNING "%s: buffer alloc failed for cpu %d\n",
-                                __func__, dtl->cpu);
-                return -ENOMEM;
-        }
+        /* check for hypervisor ring buffer overflow, ignore this entry if so */
+        if (index + N_DISPATCH_LOG < vpa->dtl_idx)
+                return;
+
+        ++wp;
+        if (wp == dtlr->buf_end)
+                wp = dtlr->buf;
+        dtlr->write_ptr = wp;
+
+        /* incrementing write_index makes the new entry visible */
+        smp_wmb();
+        ++dtlr->write_index;
+}
+
+static int dtl_start(struct dtl *dtl)
+{
+        struct dtl_ring *dtlr = &per_cpu(dtl_rings, dtl->cpu);
+
+        dtlr->buf = dtl->buf;
+        dtlr->buf_end = dtl->buf + dtl->buf_entries;
+        dtlr->write_index = 0;
+
+        /* setting write_ptr enables logging into our buffer */
+        smp_wmb();
+        dtlr->write_ptr = dtl->buf;
+
+        /* enable event logging */
+        dtlr->saved_dtl_mask = lppaca_of(dtl->cpu).dtl_enable_mask;
+        lppaca_of(dtl->cpu).dtl_enable_mask |= dtl_event_mask;
+
+        dtl_consumer = consume_dtle;
+        atomic_inc(&dtl_count);
+        return 0;
+}
+
+static void dtl_stop(struct dtl *dtl)
+{
+        struct dtl_ring *dtlr = &per_cpu(dtl_rings, dtl->cpu);
+
+        dtlr->write_ptr = NULL;
+        smp_wmb();
+
+        dtlr->buf = NULL;
+
+        /* restore dtl_enable_mask */
+        lppaca_of(dtl->cpu).dtl_enable_mask = dtlr->saved_dtl_mask;
+
+        if (atomic_dec_and_test(&dtl_count))
+                dtl_consumer = NULL;
+}
+
+static u64 dtl_current_index(struct dtl *dtl)
+{
+        return per_cpu(dtl_rings, dtl->cpu).write_index;
+}
+
+#else /* CONFIG_VIRT_CPU_ACCOUNTING */
+
+static int dtl_start(struct dtl *dtl)
+{
+        unsigned long addr;
+        int ret, hwcpu;
 
         /* Register our dtl buffer with the hypervisor. The HV expects the
          * buffer size to be passed in the second word of the buffer */
@@ -102,34 +159,82 @@ static int dtl_enable(struct dtl *dtl)
         if (ret) {
                 printk(KERN_WARNING "%s: DTL registration for cpu %d (hw %d) "
                        "failed with %d\n", __func__, dtl->cpu, hwcpu, ret);
-                kfree(dtl->buf);
                 return -EIO;
         }
 
         /* set our initial buffer indices */
-        dtl->last_idx = lppaca[dtl->cpu].dtl_idx = 0;
+        lppaca_of(dtl->cpu).dtl_idx = 0;
 
         /* ensure that our updates to the lppaca fields have occurred before
          * we actually enable the logging */
         smp_wmb();
 
         /* enable event logging */
-        lppaca[dtl->cpu].dtl_enable_mask = dtl_event_mask;
+        lppaca_of(dtl->cpu).dtl_enable_mask = dtl_event_mask;
 
         return 0;
 }
 
-static void dtl_disable(struct dtl *dtl)
+static void dtl_stop(struct dtl *dtl)
 {
         int hwcpu = get_hard_smp_processor_id(dtl->cpu);
 
-        lppaca[dtl->cpu].dtl_enable_mask = 0x0;
+        lppaca_of(dtl->cpu).dtl_enable_mask = 0x0;
 
         unregister_dtl(hwcpu, __pa(dtl->buf));
+}
+
+static u64 dtl_current_index(struct dtl *dtl)
+{
+        return lppaca_of(dtl->cpu).dtl_idx;
+}
+#endif /* CONFIG_VIRT_CPU_ACCOUNTING */
+
+static int dtl_enable(struct dtl *dtl)
+{
+        long int n_entries;
+        long int rc;
+        struct dtl_entry *buf = NULL;
 
+        /* only allow one reader */
+        if (dtl->buf)
+                return -EBUSY;
+
+        n_entries = dtl_buf_entries;
+        buf = kmalloc_node(n_entries * sizeof(struct dtl_entry),
+                        GFP_KERNEL, cpu_to_node(dtl->cpu));
+        if (!buf) {
+                printk(KERN_WARNING "%s: buffer alloc failed for cpu %d\n",
+                                __func__, dtl->cpu);
+                return -ENOMEM;
+        }
+
+        spin_lock(&dtl->lock);
+        rc = -EBUSY;
+        if (!dtl->buf) {
+                /* store the original allocation size for use during read */
+                dtl->buf_entries = n_entries;
+                dtl->buf = buf;
+                dtl->last_idx = 0;
+                rc = dtl_start(dtl);
+                if (rc)
+                        dtl->buf = NULL;
+        }
+        spin_unlock(&dtl->lock);
+
+        if (rc)
+                kfree(buf);
+        return rc;
+}
+
+static void dtl_disable(struct dtl *dtl)
+{
+        spin_lock(&dtl->lock);
+        dtl_stop(dtl);
         kfree(dtl->buf);
         dtl->buf = NULL;
         dtl->buf_entries = 0;
+        spin_unlock(&dtl->lock);
 }
 
 /* file interface */
@@ -157,8 +262,9 @@ static int dtl_file_release(struct inode *inode, struct file *filp)
 static ssize_t dtl_file_read(struct file *filp, char __user *buf, size_t len,
                 loff_t *pos)
 {
-        int rc, cur_idx, last_idx, n_read, n_req, read_size;
+        long int rc, n_read, n_req, read_size;
         struct dtl *dtl;
+        u64 cur_idx, last_idx, i;
 
         if ((len % sizeof(struct dtl_entry)) != 0)
                 return -EINVAL;
@@ -171,41 +277,48 @@ static ssize_t dtl_file_read(struct file *filp, char __user *buf, size_t len,
         /* actual number of entries read */
         n_read = 0;
 
-        cur_idx = lppaca[dtl->cpu].dtl_idx;
+        spin_lock(&dtl->lock);
+
+        cur_idx = dtl_current_index(dtl);
         last_idx = dtl->last_idx;
 
-        if (cur_idx - last_idx > dtl->buf_entries) {
-                pr_debug("%s: hv buffer overflow for cpu %d, samples lost\n",
-                                __func__, dtl->cpu);
-        }
+        if (last_idx + dtl->buf_entries <= cur_idx)
+                last_idx = cur_idx - dtl->buf_entries + 1;
+
+        if (last_idx + n_req > cur_idx)
+                n_req = cur_idx - last_idx;
+
+        if (n_req > 0)
+                dtl->last_idx = last_idx + n_req;
+
+        spin_unlock(&dtl->lock);
+
+        if (n_req <= 0)
+                return 0;
 
-        cur_idx  %= dtl->buf_entries;
-        last_idx %= dtl->buf_entries;
+        i = last_idx % dtl->buf_entries;
 
         /* read the tail of the buffer if we've wrapped */
-        if (last_idx > cur_idx) {
-                read_size = min(n_req, dtl->buf_entries - last_idx);
+        if (i + n_req > dtl->buf_entries) {
+                read_size = dtl->buf_entries - i;
 
-                rc = copy_to_user(buf, &dtl->buf[last_idx],
+                rc = copy_to_user(buf, &dtl->buf[i],
                                 read_size * sizeof(struct dtl_entry));
                 if (rc)
                         return -EFAULT;
 
-                last_idx = 0;
+                i = 0;
                 n_req -= read_size;
                 n_read += read_size;
                 buf += read_size * sizeof(struct dtl_entry);
         }
 
         /* .. and now the head */
-        read_size = min(n_req, cur_idx - last_idx);
-        rc = copy_to_user(buf, &dtl->buf[last_idx],
-                        read_size * sizeof(struct dtl_entry));
+        rc = copy_to_user(buf, &dtl->buf[i], n_req * sizeof(struct dtl_entry));
         if (rc)
                 return -EFAULT;
 
-        n_read += read_size;
-        dtl->last_idx += n_read;
+        n_read += n_req;
 
         return n_read * sizeof(struct dtl_entry);
 }
@@ -263,6 +376,7 @@ static int dtl_init(void)
         /* set up the per-cpu log structures */
         for_each_possible_cpu(i) {
                 struct dtl *dtl = &per_cpu(cpu_dtl, i);
+                spin_lock_init(&dtl->lock);
                 dtl->cpu = i;
 
                 rc = dtl_setup_file(dtl);
diff --git a/arch/powerpc/platforms/pseries/lpar.c b/arch/powerpc/platforms/pseries/lpar.c
index cf79b46d8f8..f129040d974 100644
--- a/arch/powerpc/platforms/pseries/lpar.c
+++ b/arch/powerpc/platforms/pseries/lpar.c
@@ -248,11 +248,13 @@ void vpa_init(int cpu)
         int hwcpu = get_hard_smp_processor_id(cpu);
         unsigned long addr;
         long ret;
+        struct paca_struct *pp;
+        struct dtl_entry *dtl;
 
         if (cpu_has_feature(CPU_FTR_ALTIVEC))
-                lppaca[cpu].vmxregs_in_use = 1;
+                lppaca_of(cpu).vmxregs_in_use = 1;
 
-        addr = __pa(&lppaca[cpu]);
+        addr = __pa(&lppaca_of(cpu));
         ret = register_vpa(hwcpu, addr);
 
         if (ret) {
@@ -274,6 +276,25 @@ void vpa_init(int cpu)
                                "registration for cpu %d (hw %d) of area %lx "
                                "returns %ld\n", cpu, hwcpu, addr, ret);
         }
+
+        /*
+         * Register dispatch trace log, if one has been allocated.
+         */
+        pp = &paca[cpu];
+        dtl = pp->dispatch_log;
+        if (dtl) {
+                pp->dtl_ridx = 0;
+                pp->dtl_curr = dtl;
+                lppaca_of(cpu).dtl_idx = 0;
+
+                /* hypervisor reads buffer length from this field */
+                dtl->enqueue_to_dispatch_time = DISPATCH_LOG_BYTES;
+                ret = register_dtl(hwcpu, __pa(dtl));
+                if (ret)
+                        pr_warn("DTL registration failed for cpu %d (%ld)\n",
+                                cpu, ret);
+                lppaca_of(cpu).dtl_enable_mask = 2;
+        }
 }
 
 static long pSeries_lpar_hpte_insert(unsigned long hpte_group,
diff --git a/arch/powerpc/platforms/pseries/mobility.c b/arch/powerpc/platforms/pseries/mobility.c
new file mode 100644
index 00000000000..3e7f651e50a
--- /dev/null
+++ b/arch/powerpc/platforms/pseries/mobility.c
@@ -0,0 +1,362 @@
+/*
+ * Support for Partition Mobility/Migration
+ *
+ * Copyright (C) 2010 Nathan Fontenot
+ * Copyright (C) 2010 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/kobject.h>
+#include <linux/smp.h>
+#include <linux/completion.h>
+#include <linux/device.h>
+#include <linux/delay.h>
+#include <linux/slab.h>
+
+#include <asm/rtas.h>
+#include "pseries.h"
+
+static struct kobject *mobility_kobj;
+
+struct update_props_workarea {
+        u32 phandle;
+        u32 state;
+        u64 reserved;
+        u32 nprops;
+};
+
+#define NODE_ACTION_MASK        0xff000000
+#define NODE_COUNT_MASK         0x00ffffff
+
+#define DELETE_DT_NODE  0x01000000
+#define UPDATE_DT_NODE  0x02000000
+#define ADD_DT_NODE     0x03000000
+
+static int mobility_rtas_call(int token, char *buf)
+{
+        int rc;
+
+        spin_lock(&rtas_data_buf_lock);
+
+        memcpy(rtas_data_buf, buf, RTAS_DATA_BUF_SIZE);
+        rc = rtas_call(token, 2, 1, NULL, rtas_data_buf, 1);
+        memcpy(buf, rtas_data_buf, RTAS_DATA_BUF_SIZE);
+
+        spin_unlock(&rtas_data_buf_lock);
+        return rc;
+}
+
+static int delete_dt_node(u32 phandle)
+{
+        struct device_node *dn;
+
+        dn = of_find_node_by_phandle(phandle);
+        if (!dn)
+                return -ENOENT;
+
+        dlpar_detach_node(dn);
+        return 0;
+}
+
+static int update_dt_property(struct device_node *dn, struct property **prop,
+                              const char *name, u32 vd, char *value)
+{
+        struct property *new_prop = *prop;
+        struct property *old_prop;
+        int more = 0;
+
+        /* A negative 'vd' value indicates that only part of the new property
+         * value is contained in the buffer and we need to call
+         * ibm,update-properties again to get the rest of the value.
+         *
+         * A negative value is also the two's compliment of the actual value.
+         */
+        if (vd & 0x80000000) {
+                vd = ~vd + 1;
+                more = 1;
+        }
+
+        if (new_prop) {
+                /* partial property fixup */
+                char *new_data = kzalloc(new_prop->length + vd, GFP_KERNEL);
+                if (!new_data)
+                        return -ENOMEM;
+
+                memcpy(new_data, new_prop->value, new_prop->length);
+                memcpy(new_data + new_prop->length, value, vd);
+
+                kfree(new_prop->value);
+                new_prop->value = new_data;
+                new_prop->length += vd;
+        } else {
+                new_prop = kzalloc(sizeof(*new_prop), GFP_KERNEL);
+                if (!new_prop)
+                        return -ENOMEM;
+
+                new_prop->name = kstrdup(name, GFP_KERNEL);
+                if (!new_prop->name) {
+                        kfree(new_prop);
+                        return -ENOMEM;
+                }
+
+                new_prop->length = vd;
+                new_prop->value = kzalloc(new_prop->length, GFP_KERNEL);
+                if (!new_prop->value) {
+                        kfree(new_prop->name);
+                        kfree(new_prop);
+                        return -ENOMEM;
+                }
+
+                memcpy(new_prop->value, value, vd);
+                *prop = new_prop;
+        }
+
+        if (!more) {
+                old_prop = of_find_property(dn, new_prop->name, NULL);
+                if (old_prop)
+                        prom_update_property(dn, new_prop, old_prop);
+                else
+                        prom_add_property(dn, new_prop);
+
+                new_prop = NULL;
+        }
+
+        return 0;
+}
+
+static int update_dt_node(u32 phandle)
+{
+        struct update_props_workarea *upwa;
+        struct device_node *dn;
+        struct property *prop = NULL;
+        int i, rc;
+        char *prop_data;
+        char *rtas_buf;
+        int update_properties_token;
+
+        update_properties_token = rtas_token("ibm,update-properties");
+        if (update_properties_token == RTAS_UNKNOWN_SERVICE)
+                return -EINVAL;
+
+        rtas_buf = kzalloc(RTAS_DATA_BUF_SIZE, GFP_KERNEL);
+        if (!rtas_buf)
+                return -ENOMEM;
+
+        dn = of_find_node_by_phandle(phandle);
+        if (!dn) {
+                kfree(rtas_buf);
+                return -ENOENT;
+        }
+
+        upwa = (struct update_props_workarea *)&rtas_buf[0];
+        upwa->phandle = phandle;
+
+        do {
+                rc = mobility_rtas_call(update_properties_token, rtas_buf);
+                if (rc < 0)
+                        break;
+
+                prop_data = rtas_buf + sizeof(*upwa);
+
+                for (i = 0; i < upwa->nprops; i++) {
+                        char *prop_name;
+                        u32 vd;
+
+                        prop_name = prop_data + 1;
+                        prop_data += strlen(prop_name) + 1;
+                        vd = *prop_data++;
+
+                        switch (vd) {
+                        case 0x00000000:
+                                /* name only property, nothing to do */
+                                break;
+
+                        case 0x80000000:
+                                prop = of_find_property(dn, prop_name, NULL);
+                                prom_remove_property(dn, prop);
+                                prop = NULL;
+                                break;
+
+                        default:
+                                rc = update_dt_property(dn, &prop, prop_name,
+                                                        vd, prop_data);
+                                if (rc) {
+                                        printk(KERN_ERR "Could not update %s"
+                                               " property\n", prop_name);
+                                }
+
+                                prop_data += vd;
+                        }
+                }
+        } while (rc == 1);
+
+        of_node_put(dn);
+        kfree(rtas_buf);
+        return 0;
+}
+
+static int add_dt_node(u32 parent_phandle, u32 drc_index)
+{
+        struct device_node *dn;
+        struct device_node *parent_dn;
+        int rc;
+
+        dn = dlpar_configure_connector(drc_index);
+        if (!dn)
+                return -ENOENT;
+
+        parent_dn = of_find_node_by_phandle(parent_phandle);
+        if (!parent_dn) {
+                dlpar_free_cc_nodes(dn);
+                return -ENOENT;
+        }
+
+        dn->parent = parent_dn;
+        rc = dlpar_attach_node(dn);
+        if (rc)
+                dlpar_free_cc_nodes(dn);
+
+        of_node_put(parent_dn);
+        return rc;
+}
+
+static int pseries_devicetree_update(void)
+{
+        char *rtas_buf;
+        u32 *data;
+        int update_nodes_token;
+        int rc;
+
+        update_nodes_token = rtas_token("ibm,update-nodes");
+        if (update_nodes_token == RTAS_UNKNOWN_SERVICE)
+                return -EINVAL;
+
+        rtas_buf = kzalloc(RTAS_DATA_BUF_SIZE, GFP_KERNEL);
+        if (!rtas_buf)
+                return -ENOMEM;
+
+        do {
+                rc = mobility_rtas_call(update_nodes_token, rtas_buf);
+                if (rc && rc != 1)
+                        break;
+
+                data = (u32 *)rtas_buf + 4;
+                while (*data & NODE_ACTION_MASK) {
+                        int i;
+                        u32 action = *data & NODE_ACTION_MASK;
+                        int node_count = *data & NODE_COUNT_MASK;
+
+                        data++;
+
+                        for (i = 0; i < node_count; i++) {
+                                u32 phandle = *data++;
+                                u32 drc_index;
+
+                                switch (action) {
+                                case DELETE_DT_NODE:
+                                        delete_dt_node(phandle);
+                                        break;
+                                case UPDATE_DT_NODE:
+                                        update_dt_node(phandle);
+                                        break;
+                                case ADD_DT_NODE:
+                                        drc_index = *data++;
+                                        add_dt_node(phandle, drc_index);
+                                        break;
+                                }
+                        }
+                }
+        } while (rc == 1);
+
+        kfree(rtas_buf);
+        return rc;
+}
+
+void post_mobility_fixup(void)
+{
+        int rc;
+        int activate_fw_token;
+
+        rc = pseries_devicetree_update();
+        if (rc) {
+                printk(KERN_ERR "Initial post-mobility device tree update "
+                       "failed: %d\n", rc);
+                return;
+        }
+
+        activate_fw_token = rtas_token("ibm,activate-firmware");
+        if (activate_fw_token == RTAS_UNKNOWN_SERVICE) {
+                printk(KERN_ERR "Could not make post-mobility "
+                       "activate-fw call.\n");
+                return;
+        }
+
+        rc = rtas_call(activate_fw_token, 0, 1, NULL);
+        if (!rc) {
+                rc = pseries_devicetree_update();
+                if (rc)
+                        printk(KERN_ERR "Secondary post-mobility device tree "
+                               "update failed: %d\n", rc);
+        } else {
+                printk(KERN_ERR "Post-mobility activate-fw failed: %d\n", rc);
+                return;
+        }
+
+        return;
+}
+
+static ssize_t migrate_store(struct class *class, struct class_attribute *attr,
+                             const char *buf, size_t count)
+{
+        struct rtas_args args;
+        u64 streamid;
+        int rc;
+
+        rc = strict_strtoull(buf, 0, &streamid);
+        if (rc)
+                return rc;
+
+        memset(&args, 0, sizeof(args));
+        args.token = rtas_token("ibm,suspend-me");
+        args.nargs = 2;
+        args.nret = 1;
+
+        args.args[0] = streamid >> 32 ;
+        args.args[1] = streamid & 0xffffffff;
+        args.rets = &args.args[args.nargs];
+
+        do {
+                args.rets[0] = 0;
+                rc = rtas_ibm_suspend_me(&args);
+                if (!rc && args.rets[0] == RTAS_NOT_SUSPENDABLE)
+                        ssleep(1);
+        } while (!rc && args.rets[0] == RTAS_NOT_SUSPENDABLE);
+
+        if (rc)
+                return rc;
+        else if (args.rets[0])
+                return args.rets[0];
+
+        post_mobility_fixup();
+        return count;
+}
+
+static CLASS_ATTR(migration, S_IWUSR, NULL, migrate_store);
+
+static int __init mobility_sysfs_init(void)
+{
+        int rc;
+
+        mobility_kobj = kobject_create_and_add("mobility", kernel_kobj);
+        if (!mobility_kobj)
+                return -ENOMEM;
+
+        rc = sysfs_create_file(mobility_kobj, &class_attr_migration.attr);
+
+        return rc;
+}
+device_initcall(mobility_sysfs_init);
diff --git a/arch/powerpc/platforms/pseries/pseries.h b/arch/powerpc/platforms/pseries/pseries.h
index 40c93cad91d..e9f6d2859c3 100644
--- a/arch/powerpc/platforms/pseries/pseries.h
+++ b/arch/powerpc/platforms/pseries/pseries.h
@@ -17,6 +17,8 @@ struct device_node;
 extern void request_event_sources_irqs(struct device_node *np,
                                        irq_handler_t handler, const char *name);
 
+#include <linux/of.h>
+
 extern void __init fw_feature_init(const char *hypertas, unsigned long len);
 
 struct pt_regs;
@@ -47,4 +49,11 @@ extern unsigned long rtas_poweron_auto;
 
 extern void find_udbg_vterm(void);
 
+/* Dynamic logical Partitioning/Mobility */
+extern void dlpar_free_cc_nodes(struct device_node *);
+extern void dlpar_free_cc_property(struct property *);
+extern struct device_node *dlpar_configure_connector(u32);
+extern int dlpar_attach_node(struct device_node *);
+extern int dlpar_detach_node(struct device_node *);
+
 #endif /* _PSERIES_PSERIES_H */
diff --git a/arch/powerpc/platforms/pseries/setup.c b/arch/powerpc/platforms/pseries/setup.c
index a6d19e3a505..d345bfd56bb 100644
--- a/arch/powerpc/platforms/pseries/setup.c
+++ b/arch/powerpc/platforms/pseries/setup.c
@@ -273,6 +273,58 @@ static struct notifier_block pci_dn_reconfig_nb = {
         .notifier_call = pci_dn_reconfig_notifier,
 };
 
+#ifdef CONFIG_VIRT_CPU_ACCOUNTING
+/*
+ * Allocate space for the dispatch trace log for all possible cpus
+ * and register the buffers with the hypervisor.  This is used for
+ * computing time stolen by the hypervisor.
+ */
+static int alloc_dispatch_logs(void)
+{
+        int cpu, ret;
+        struct paca_struct *pp;
+        struct dtl_entry *dtl;
+
+        if (!firmware_has_feature(FW_FEATURE_SPLPAR))
+                return 0;
+
+        for_each_possible_cpu(cpu) {
+                pp = &paca[cpu];
+                dtl = kmalloc_node(DISPATCH_LOG_BYTES, GFP_KERNEL,
+                                   cpu_to_node(cpu));
+                if (!dtl) {
+                        pr_warn("Failed to allocate dispatch trace log for cpu %d\n",
+                                cpu);
+                        pr_warn("Stolen time statistics will be unreliable\n");
+                        break;
+                }
+
+                pp->dtl_ridx = 0;
+                pp->dispatch_log = dtl;
+                pp->dispatch_log_end = dtl + N_DISPATCH_LOG;
+                pp->dtl_curr = dtl;
+        }
+
+        /* Register the DTL for the current (boot) cpu */
+        dtl = get_paca()->dispatch_log;
+        get_paca()->dtl_ridx = 0;
+        get_paca()->dtl_curr = dtl;
+        get_paca()->lppaca_ptr->dtl_idx = 0;
+
+        /* hypervisor reads buffer length from this field */
+        dtl->enqueue_to_dispatch_time = DISPATCH_LOG_BYTES;
+        ret = register_dtl(hard_smp_processor_id(), __pa(dtl));
+        if (ret)
+                pr_warn("DTL registration failed for boot cpu %d (%d)\n",
+                        smp_processor_id(), ret);
+        get_paca()->lppaca_ptr->dtl_enable_mask = 2;
+
+        return 0;
+}
+
+early_initcall(alloc_dispatch_logs);
+#endif /* CONFIG_VIRT_CPU_ACCOUNTING */
+
 static void __init pSeries_setup_arch(void)
 {
         /* Discover PIC type and setup ppc_md accordingly */
diff --git a/arch/powerpc/platforms/pseries/xics.c b/arch/powerpc/platforms/pseries/xics.c
index 67e2c4bdac8..7b96e5a270c 100644
--- a/arch/powerpc/platforms/pseries/xics.c
+++ b/arch/powerpc/platforms/pseries/xics.c
@@ -178,7 +178,7 @@ static int get_irq_server(unsigned int virq, const struct cpumask *cpumask,
         if (!distribute_irqs)
                 return default_server;
 
-        if (!cpumask_equal(cpumask, cpu_all_mask)) {
+        if (!cpumask_subset(cpu_possible_mask, cpumask)) {
                 int server = cpumask_first_and(cpu_online_mask, cpumask);
 
                 if (server < nr_cpu_ids)