24 files changed, 2213 insertions, 459 deletions

diff --git a/drivers/base/platform.c b/drivers/base/platform.c
index b2afc29403f9..233ececd15a3 100644
--- a/drivers/base/platform.c
+++ b/drivers/base/platform.c
@@ -1006,6 +1006,7 @@ int __init platform_bus_init(void)
         error =  bus_register(&platform_bus_type);
         if (error)
                 device_unregister(&platform_bus);
+        of_platform_register_reconfig_notifier();
         return error;
 }
 
diff --git a/drivers/crypto/nx/nx-842.c b/drivers/crypto/nx/nx-842.c
index 061407d59520..887196e9b50c 100644
--- a/drivers/crypto/nx/nx-842.c
+++ b/drivers/crypto/nx/nx-842.c
@@ -1009,9 +1009,9 @@ error_out:
  *              notifier_to_errno() to decode this value
  */
 static int nx842_OF_notifier(struct notifier_block *np, unsigned long action,
-                             void *update)
+                             void *data)
 {
-        struct of_prop_reconfig *upd = update;
+        struct of_reconfig_data *upd = data;
         struct nx842_devdata *local_devdata;
         struct device_node *node = NULL;
 
diff --git a/drivers/i2c/i2c-core.c b/drivers/i2c/i2c-core.c
index 68aeb8eedae0..229a89e84b0f 100644
--- a/drivers/i2c/i2c-core.c
+++ b/drivers/i2c/i2c-core.c
@@ -49,6 +49,7 @@
 #include <linux/acpi.h>
 #include <linux/jump_label.h>
 #include <asm/uaccess.h>
+#include <linux/err.h>
 
 #include "i2c-core.h"
 
@@ -1369,63 +1370,69 @@ static void i2c_scan_static_board_info(struct i2c_adapter *adapter)
 /* OF support code */
 
 #if IS_ENABLED(CONFIG_OF)
-static void of_i2c_register_devices(struct i2c_adapter *adap)
+static struct i2c_client *of_i2c_register_device(struct i2c_adapter *adap,
+                                                 struct device_node *node)
 {
-        void *result;
-        struct device_node *node;
+        struct i2c_client *result;
+        struct i2c_board_info info = {};
+        struct dev_archdata dev_ad = {};
+        const __be32 *addr;
+        int len;
 
-        /* Only register child devices if the adapter has a node pointer set */
-        if (!adap->dev.of_node)
-                return;
+        dev_dbg(&adap->dev, "of_i2c: register %s\n", node->full_name);
 
-        dev_dbg(&adap->dev, "of_i2c: walking child nodes\n");
+        if (of_modalias_node(node, info.type, sizeof(info.type)) < 0) {
+                dev_err(&adap->dev, "of_i2c: modalias failure on %s\n",
+                        node->full_name);
+                return ERR_PTR(-EINVAL);
+        }
 
-        for_each_available_child_of_node(adap->dev.of_node, node) {
-                struct i2c_board_info info = {};
-                struct dev_archdata dev_ad = {};
-                const __be32 *addr;
-                int len;
+        addr = of_get_property(node, "reg", &len);
+        if (!addr || (len < sizeof(int))) {
+                dev_err(&adap->dev, "of_i2c: invalid reg on %s\n",
+                        node->full_name);
+                return ERR_PTR(-EINVAL);
+        }
 
-                dev_dbg(&adap->dev, "of_i2c: register %s\n", node->full_name);
+        info.addr = be32_to_cpup(addr);
+        if (info.addr > (1 << 10) - 1) {
+                dev_err(&adap->dev, "of_i2c: invalid addr=%x on %s\n",
+                        info.addr, node->full_name);
+                return ERR_PTR(-EINVAL);
+        }
 
-                if (of_modalias_node(node, info.type, sizeof(info.type)) < 0) {
-                        dev_err(&adap->dev, "of_i2c: modalias failure on %s\n",
-                                node->full_name);
-                        continue;
-                }
+        info.irq = irq_of_parse_and_map(node, 0);
+        info.of_node = of_node_get(node);
+        info.archdata = &dev_ad;
 
-                addr = of_get_property(node, "reg", &len);
-                if (!addr || (len < sizeof(int))) {
-                        dev_err(&adap->dev, "of_i2c: invalid reg on %s\n",
-                                node->full_name);
-                        continue;
-                }
+        if (of_get_property(node, "wakeup-source", NULL))
+                info.flags |= I2C_CLIENT_WAKE;
 
-                info.addr = be32_to_cpup(addr);
-                if (info.addr > (1 << 10) - 1) {
-                        dev_err(&adap->dev, "of_i2c: invalid addr=%x on %s\n",
-                                info.addr, node->full_name);
-                        continue;
-                }
+        request_module("%s%s", I2C_MODULE_PREFIX, info.type);
+
+        result = i2c_new_device(adap, &info);
+        if (result == NULL) {
+                dev_err(&adap->dev, "of_i2c: Failure registering %s\n",
+                        node->full_name);
+                of_node_put(node);
+                irq_dispose_mapping(info.irq);
+                return ERR_PTR(-EINVAL);
+        }
+        return result;
+}
 
-                info.irq = irq_of_parse_and_map(node, 0);
-                info.of_node = of_node_get(node);
-                info.archdata = &dev_ad;
+static void of_i2c_register_devices(struct i2c_adapter *adap)
+{
+        struct device_node *node;
 
-                if (of_get_property(node, "wakeup-source", NULL))
-                        info.flags |= I2C_CLIENT_WAKE;
+        /* Only register child devices if the adapter has a node pointer set */
+        if (!adap->dev.of_node)
+                return;
 
-                request_module("%s%s", I2C_MODULE_PREFIX, info.type);
+        dev_dbg(&adap->dev, "of_i2c: walking child nodes\n");
 
-                result = i2c_new_device(adap, &info);
-                if (result == NULL) {
-                        dev_err(&adap->dev, "of_i2c: Failure registering %s\n",
-                                node->full_name);
-                        of_node_put(node);
-                        irq_dispose_mapping(info.irq);
-                        continue;
-                }
-        }
+        for_each_available_child_of_node(adap->dev.of_node, node)
+                of_i2c_register_device(adap, node);
 }
 
 static int of_dev_node_match(struct device *dev, void *data)
@@ -1945,6 +1952,52 @@ void i2c_clients_command(struct i2c_adapter *adap, unsigned int cmd, void *arg)
 }
 EXPORT_SYMBOL(i2c_clients_command);
 
+#if IS_ENABLED(CONFIG_OF_DYNAMIC)
+static int of_i2c_notify(struct notifier_block *nb, unsigned long action,
+                         void *arg)
+{
+        struct of_reconfig_data *rd = arg;
+        struct i2c_adapter *adap;
+        struct i2c_client *client;
+
+        switch (of_reconfig_get_state_change(action, rd)) {
+        case OF_RECONFIG_CHANGE_ADD:
+                adap = of_find_i2c_adapter_by_node(rd->dn->parent);
+                if (adap == NULL)
+                        return NOTIFY_OK;       /* not for us */
+
+                client = of_i2c_register_device(adap, rd->dn);
+                put_device(&adap->dev);
+
+                if (IS_ERR(client)) {
+                        pr_err("%s: failed to create for '%s'\n",
+                                        __func__, rd->dn->full_name);
+                        return notifier_from_errno(PTR_ERR(client));
+                }
+                break;
+        case OF_RECONFIG_CHANGE_REMOVE:
+                /* find our device by node */
+                client = of_find_i2c_device_by_node(rd->dn);
+                if (client == NULL)
+                        return NOTIFY_OK;       /* no? not meant for us */
+
+                /* unregister takes one ref away */
+                i2c_unregister_device(client);
+
+                /* and put the reference of the find */
+                put_device(&client->dev);
+                break;
+        }
+
+        return NOTIFY_OK;
+}
+static struct notifier_block i2c_of_notifier = {
+        .notifier_call = of_i2c_notify,
+};
+#else
+extern struct notifier_block i2c_of_notifier;
+#endif /* CONFIG_OF_DYNAMIC */
+
 static int __init i2c_init(void)
 {
         int retval;
@@ -1962,6 +2015,10 @@ static int __init i2c_init(void)
         retval = i2c_add_driver(&dummy_driver);
         if (retval)
                 goto class_err;
+
+        if (IS_ENABLED(CONFIG_OF_DYNAMIC))
+                WARN_ON(of_reconfig_notifier_register(&i2c_of_notifier));
+
         return 0;
 
 class_err:
@@ -1975,6 +2032,8 @@ bus_err:
 
 static void __exit i2c_exit(void)
 {
+        if (IS_ENABLED(CONFIG_OF_DYNAMIC))
+                WARN_ON(of_reconfig_notifier_unregister(&i2c_of_notifier));
         i2c_del_driver(&dummy_driver);
 #ifdef CONFIG_I2C_COMPAT
         class_compat_unregister(i2c_adapter_compat_class);
diff --git a/drivers/mfd/vexpress-sysreg.c b/drivers/mfd/vexpress-sysreg.c
index 9e21e4fc9599..8f43ab8fd2d6 100644
--- a/drivers/mfd/vexpress-sysreg.c
+++ b/drivers/mfd/vexpress-sysreg.c
@@ -223,7 +223,7 @@ static int vexpress_sysreg_probe(struct platform_device *pdev)
         vexpress_config_set_master(vexpress_sysreg_get_master());
 
         /* Confirm board type against DT property, if available */
-        if (of_property_read_u32(of_allnodes, "arm,hbi", &dt_hbi) == 0) {
+        if (of_property_read_u32(of_root, "arm,hbi", &dt_hbi) == 0) {
                 u32 id = vexpress_get_procid(VEXPRESS_SITE_MASTER);
                 u32 hbi = (id >> SYS_PROCIDx_HBI_SHIFT) & SYS_HBI_MASK;
 
diff --git a/drivers/of/Kconfig b/drivers/of/Kconfig
index 1a13f5b722c5..b5e0c873d4e1 100644
--- a/drivers/of/Kconfig
+++ b/drivers/of/Kconfig
@@ -7,8 +7,8 @@ config OF
 menu "Device Tree and Open Firmware support"
         depends on OF
 
-config OF_SELFTEST
-        bool "Device Tree Runtime self tests"
+config OF_UNITTEST
+        bool "Device Tree runtime unit tests"
         depends on OF_IRQ && OF_EARLY_FLATTREE
         select OF_DYNAMIC
         select OF_RESOLVE
@@ -23,6 +23,7 @@ config OF_FLATTREE
         bool
         select DTC
         select LIBFDT
+        select CRC32
 
 config OF_EARLY_FLATTREE
         bool
@@ -83,4 +84,10 @@ config OF_RESERVED_MEM
 config OF_RESOLVE
         bool
 
+config OF_OVERLAY
+        bool
+        depends on OF
+        select OF_DYNAMIC
+        select OF_RESOLVE
+
 endmenu # OF
diff --git a/drivers/of/Makefile b/drivers/of/Makefile
index ca9209ce50cd..7563f36c71db 100644
--- a/drivers/of/Makefile
+++ b/drivers/of/Makefile
@@ -6,14 +6,15 @@ obj-$(CONFIG_OF_PROMTREE) += pdt.o
 obj-$(CONFIG_OF_ADDRESS)  += address.o
 obj-$(CONFIG_OF_IRQ)    += irq.o
 obj-$(CONFIG_OF_NET)    += of_net.o
-obj-$(CONFIG_OF_SELFTEST) += of_selftest.o
-of_selftest-objs := selftest.o testcase-data/testcases.dtb.o
+obj-$(CONFIG_OF_UNITTEST) += of_unittest.o
+of_unittest-objs := unittest.o unittest-data/testcases.dtb.o
 obj-$(CONFIG_OF_MDIO)   += of_mdio.o
 obj-$(CONFIG_OF_PCI)    += of_pci.o
 obj-$(CONFIG_OF_PCI_IRQ)  += of_pci_irq.o
 obj-$(CONFIG_OF_MTD)    += of_mtd.o
 obj-$(CONFIG_OF_RESERVED_MEM) += of_reserved_mem.o
 obj-$(CONFIG_OF_RESOLVE)  += resolver.o
+obj-$(CONFIG_OF_OVERLAY) += overlay.o
 
 CFLAGS_fdt.o = -I$(src)/../../scripts/dtc/libfdt
 CFLAGS_fdt_address.o = -I$(src)/../../scripts/dtc/libfdt
diff --git a/drivers/of/address.c b/drivers/of/address.c
index 06af494184d6..ad2906919d45 100644
--- a/drivers/of/address.c
+++ b/drivers/of/address.c
@@ -491,7 +491,7 @@ static int of_translate_one(struct device_node *parent, struct of_bus *bus,
          */
         ranges = of_get_property(parent, rprop, &rlen);
         if (ranges == NULL && !of_empty_ranges_quirk()) {
-                pr_err("OF: no ranges; cannot translate\n");
+                pr_debug("OF: no ranges; cannot translate\n");
                 return 1;
         }
         if (ranges == NULL || rlen == 0) {
@@ -884,7 +884,7 @@ EXPORT_SYMBOL(of_iomap);
  *              return PTR_ERR(base);
  */
 void __iomem *of_io_request_and_map(struct device_node *np, int index,
-                                        char *name)
+                                        const char *name)
 {
         struct resource res;
         void __iomem *mem;
diff --git a/drivers/of/base.c b/drivers/of/base.c
index 4c2ccde42427..36536b6a8834 100644
--- a/drivers/of/base.c
+++ b/drivers/of/base.c
@@ -32,11 +32,12 @@
 
 LIST_HEAD(aliases_lookup);
 
-struct device_node *of_allnodes;
-EXPORT_SYMBOL(of_allnodes);
+struct device_node *of_root;
+EXPORT_SYMBOL(of_root);
 struct device_node *of_chosen;
 struct device_node *of_aliases;
 struct device_node *of_stdout;
+static const char *of_stdout_options;
 
 struct kset *of_kset;
 
@@ -48,7 +49,7 @@ struct kset *of_kset;
  */
 DEFINE_MUTEX(of_mutex);
 
-/* use when traversing tree through the allnext, child, sibling,
+/* use when traversing tree through the child, sibling,
  * or parent members of struct device_node.
  */
 DEFINE_RAW_SPINLOCK(devtree_lock);
@@ -204,7 +205,7 @@ static int __init of_init(void)
         mutex_unlock(&of_mutex);
 
         /* Symlink in /proc as required by userspace ABI */
-        if (of_allnodes)
+        if (of_root)
                 proc_symlink("device-tree", NULL, "/sys/firmware/devicetree/base");
 
         return 0;
@@ -245,6 +246,23 @@ struct property *of_find_property(const struct device_node *np,
 }
 EXPORT_SYMBOL(of_find_property);
 
+struct device_node *__of_find_all_nodes(struct device_node *prev)
+{
+        struct device_node *np;
+        if (!prev) {
+                np = of_root;
+        } else if (prev->child) {
+                np = prev->child;
+        } else {
+                /* Walk back up looking for a sibling, or the end of the structure */
+                np = prev;
+                while (np->parent && !np->sibling)
+                        np = np->parent;
+                np = np->sibling; /* Might be null at the end of the tree */
+        }
+        return np;
+}
+
 /**
  * of_find_all_nodes - Get next node in global list
  * @prev:       Previous node or NULL to start iteration
@@ -259,10 +277,8 @@ struct device_node *of_find_all_nodes(struct device_node *prev)
         unsigned long flags;
 
         raw_spin_lock_irqsave(&devtree_lock, flags);
-        np = prev ? prev->allnext : of_allnodes;
-        for (; np != NULL; np = np->allnext)
-                if (of_node_get(np))
-                        break;
+        np = __of_find_all_nodes(prev);
+        of_node_get(np);
         of_node_put(prev);
         raw_spin_unlock_irqrestore(&devtree_lock, flags);
         return np;
@@ -485,7 +501,7 @@ EXPORT_SYMBOL(of_device_is_compatible);
  * of_machine_is_compatible - Test root of device tree for a given compatible value
  * @compat: compatible string to look for in root node's compatible property.
  *
- * Returns true if the root node has the given value in its
+ * Returns a positive integer if the root node has the given value in its
  * compatible property.
  */
 int of_machine_is_compatible(const char *compat)
@@ -507,27 +523,27 @@ EXPORT_SYMBOL(of_machine_is_compatible);
  *
  *  @device: Node to check for availability, with locks already held
  *
- *  Returns 1 if the status property is absent or set to "okay" or "ok",
- *  0 otherwise
+ *  Returns true if the status property is absent or set to "okay" or "ok",
+ *  false otherwise
  */
-static int __of_device_is_available(const struct device_node *device)
+static bool __of_device_is_available(const struct device_node *device)
 {
         const char *status;
         int statlen;
 
         if (!device)
-                return 0;
+                return false;
 
         status = __of_get_property(device, "status", &statlen);
         if (status == NULL)
-                return 1;
+                return true;
 
         if (statlen > 0) {
                 if (!strcmp(status, "okay") || !strcmp(status, "ok"))
-                        return 1;
+                        return true;
         }
 
-        return 0;
+        return false;
 }
 
 /**
@@ -535,13 +551,13 @@ static int __of_device_is_available(const struct device_node *device)
  *
  *  @device: Node to check for availability
  *
- *  Returns 1 if the status property is absent or set to "okay" or "ok",
- *  0 otherwise
+ *  Returns true if the status property is absent or set to "okay" or "ok",
+ *  false otherwise
  */
-int of_device_is_available(const struct device_node *device)
+bool of_device_is_available(const struct device_node *device)
 {
         unsigned long flags;
-        int res;
+        bool res;
 
         raw_spin_lock_irqsave(&devtree_lock, flags);
         res = __of_device_is_available(device);
@@ -577,9 +593,9 @@ EXPORT_SYMBOL(of_get_parent);
  *      of_get_next_parent - Iterate to a node's parent
  *      @node:  Node to get parent of
  *
- *      This is like of_get_parent() except that it drops the
- *      refcount on the passed node, making it suitable for iterating
- *      through a node's parents.
+ *      This is like of_get_parent() except that it drops the
+ *      refcount on the passed node, making it suitable for iterating
+ *      through a node's parents.
  *
  *      Returns a node pointer with refcount incremented, use
  *      of_node_put() on it when done.
@@ -699,10 +715,15 @@ static struct device_node *__of_find_node_by_path(struct device_node *parent,
 {
         struct device_node *child;
         int len = strchrnul(path, '/') - path;
+        int term;
 
         if (!len)
                 return NULL;
 
+        term = strchrnul(path, ':') - path;
+        if (term < len)
+                len = term;
+
         __for_each_child_of_node(parent, child) {
                 const char *name = strrchr(child->full_name, '/');
                 if (WARN(!name, "malformed device_node %s\n", child->full_name))
@@ -715,11 +736,14 @@ static struct device_node *__of_find_node_by_path(struct device_node *parent,
 }
 
 /**
- *      of_find_node_by_path - Find a node matching a full OF path
+ *      of_find_node_opts_by_path - Find a node matching a full OF path
  *      @path: Either the full path to match, or if the path does not
  *             start with '/', the name of a property of the /aliases
  *             node (an alias).  In the case of an alias, the node
  *             matching the alias' value will be returned.
+ *      @opts: Address of a pointer into which to store the start of
+ *             an options string appended to the end of the path with
+ *             a ':' separator.
  *
  *      Valid paths:
  *              /foo/bar        Full path
@@ -729,19 +753,23 @@ static struct device_node *__of_find_node_by_path(struct device_node *parent,
  *      Returns a node pointer with refcount incremented, use
  *      of_node_put() on it when done.
  */
-struct device_node *of_find_node_by_path(const char *path)
+struct device_node *of_find_node_opts_by_path(const char *path, const char **opts)
 {
         struct device_node *np = NULL;
         struct property *pp;
         unsigned long flags;
+        const char *separator = strchr(path, ':');
+
+        if (opts)
+                *opts = separator ? separator + 1 : NULL;
 
         if (strcmp(path, "/") == 0)
-                return of_node_get(of_allnodes);
+                return of_node_get(of_root);
 
         /* The path could begin with an alias */
         if (*path != '/') {
                 char *p = strchrnul(path, '/');
-                int len = p - path;
+                int len = separator ? separator - path : p - path;
 
                 /* of_aliases must not be NULL */
                 if (!of_aliases)
@@ -761,7 +789,7 @@ struct device_node *of_find_node_by_path(const char *path)
         /* Step down the tree matching path components */
         raw_spin_lock_irqsave(&devtree_lock, flags);
         if (!np)
-                np = of_node_get(of_allnodes);
+                np = of_node_get(of_root);
         while (np && *path == '/') {
                 path++; /* Increment past '/' delimiter */
                 np = __of_find_node_by_path(np, path);
@@ -770,7 +798,7 @@ struct device_node *of_find_node_by_path(const char *path)
         raw_spin_unlock_irqrestore(&devtree_lock, flags);
         return np;
 }
-EXPORT_SYMBOL(of_find_node_by_path);
+EXPORT_SYMBOL(of_find_node_opts_by_path);
 
 /**
  *      of_find_node_by_name - Find a node by its "name" property
@@ -790,8 +818,7 @@ struct device_node *of_find_node_by_name(struct device_node *from,
         unsigned long flags;
 
         raw_spin_lock_irqsave(&devtree_lock, flags);
-        np = from ? from->allnext : of_allnodes;
-        for (; np; np = np->allnext)
+        for_each_of_allnodes_from(from, np)
                 if (np->name && (of_node_cmp(np->name, name) == 0)
                     && of_node_get(np))
                         break;
@@ -820,8 +847,7 @@ struct device_node *of_find_node_by_type(struct device_node *from,
         unsigned long flags;
 
         raw_spin_lock_irqsave(&devtree_lock, flags);
-        np = from ? from->allnext : of_allnodes;
-        for (; np; np = np->allnext)
+        for_each_of_allnodes_from(from, np)
                 if (np->type && (of_node_cmp(np->type, type) == 0)
                     && of_node_get(np))
                         break;
@@ -852,12 +878,10 @@ struct device_node *of_find_compatible_node(struct device_node *from,
         unsigned long flags;
 
         raw_spin_lock_irqsave(&devtree_lock, flags);
-        np = from ? from->allnext : of_allnodes;
-        for (; np; np = np->allnext) {
+        for_each_of_allnodes_from(from, np)
                 if (__of_device_is_compatible(np, compatible, type, NULL) &&
                     of_node_get(np))
                         break;
-        }
         of_node_put(from);
         raw_spin_unlock_irqrestore(&devtree_lock, flags);
         return np;
@@ -884,8 +908,7 @@ struct device_node *of_find_node_with_property(struct device_node *from,
         unsigned long flags;
 
         raw_spin_lock_irqsave(&devtree_lock, flags);
-        np = from ? from->allnext : of_allnodes;
-        for (; np; np = np->allnext) {
+        for_each_of_allnodes_from(from, np) {
                 for (pp = np->properties; pp; pp = pp->next) {
                         if (of_prop_cmp(pp->name, prop_name) == 0) {
                                 of_node_get(np);
@@ -923,7 +946,7 @@ const struct of_device_id *__of_match_node(const struct of_device_id *matches,
 }
 
 /**
- * of_match_node - Tell if an device_node has a matching of_match structure
+ * of_match_node - Tell if a device_node has a matching of_match structure
  *      @matches:       array of of device match structures to search in
  *      @node:          the of device structure to match against
  *
@@ -967,8 +990,7 @@ struct device_node *of_find_matching_node_and_match(struct device_node *from,
                 *match = NULL;
 
         raw_spin_lock_irqsave(&devtree_lock, flags);
-        np = from ? from->allnext : of_allnodes;
-        for (; np; np = np->allnext) {
+        for_each_of_allnodes_from(from, np) {
                 m = __of_match_node(matches, np);
                 if (m && of_node_get(np)) {
                         if (match)
@@ -1025,7 +1047,7 @@ struct device_node *of_find_node_by_phandle(phandle handle)
                 return NULL;
 
         raw_spin_lock_irqsave(&devtree_lock, flags);
-        for (np = of_allnodes; np; np = np->allnext)
+        for_each_of_allnodes(np)
                 if (np->phandle == handle)
                         break;
         of_node_get(np);
@@ -1350,7 +1372,7 @@ int of_property_match_string(struct device_node *np, const char *propname,
 EXPORT_SYMBOL_GPL(of_property_match_string);
 
 /**
- * of_property_read_string_util() - Utility helper for parsing string properties
+ * of_property_read_string_helper() - Utility helper for parsing string properties
  * @np:         device node from which the property value is to be read.
  * @propname:   name of the property to be searched.
  * @out_strs:   output array of string pointers.
@@ -1549,21 +1571,21 @@ EXPORT_SYMBOL(of_parse_phandle);
  * Returns 0 on success and fills out_args, on error returns appropriate
  * errno value.
  *
- * Caller is responsible to call of_node_put() on the returned out_args->node
+ * Caller is responsible to call of_node_put() on the returned out_args->np
  * pointer.
  *
  * Example:
  *
  * phandle1: node1 {
- *      #list-cells = <2>;
+ *      #list-cells = <2>;
  * }
  *
  * phandle2: node2 {
- *      #list-cells = <1>;
+ *      #list-cells = <1>;
  * }
  *
  * node3 {
- *      list = <&phandle1 1 2 &phandle2 3>;
+ *      list = <&phandle1 1 2 &phandle2 3>;
  * }
  *
  * To get a device_node of the `node2' node you may call this:
@@ -1592,7 +1614,7 @@ EXPORT_SYMBOL(of_parse_phandle_with_args);
  * Returns 0 on success and fills out_args, on error returns appropriate
  * errno value.
  *
- * Caller is responsible to call of_node_put() on the returned out_args->node
+ * Caller is responsible to call of_node_put() on the returned out_args->np
  * pointer.
  *
  * Example:
@@ -1604,7 +1626,7 @@ EXPORT_SYMBOL(of_parse_phandle_with_args);
  * }
  *
  * node3 {
- *      list = <&phandle1 0 2 &phandle2 2 3>;
+ *      list = <&phandle1 0 2 &phandle2 2 3>;
  * }
  *
  * To get a device_node of the `node2' node you may call this:
@@ -1838,14 +1860,14 @@ static void of_alias_add(struct alias_prop *ap, struct device_node *np,
 }
 
 /**
- * of_alias_scan - Scan all properties of 'aliases' node
+ * of_alias_scan - Scan all properties of the 'aliases' node
  *
- * The function scans all the properties of 'aliases' node and populate
- * the the global lookup table with the properties.  It returns the
- * number of alias_prop found, or error code in error case.
+ * The function scans all the properties of the 'aliases' node and populates
+ * the global lookup table with the properties.  It returns the
+ * number of alias properties found, or an error code in case of failure.
  *
  * @dt_alloc:   An allocator that provides a virtual address to memory
- *              for the resulting tree
+ *              for storing the resulting tree
  */
 void of_alias_scan(void * (*dt_alloc)(u64 size, u64 align))
 {
@@ -1864,7 +1886,7 @@ void of_alias_scan(void * (*dt_alloc)(u64 size, u64 align))
                 if (IS_ENABLED(CONFIG_PPC) && !name)
                         name = of_get_property(of_aliases, "stdout", NULL);
                 if (name)
-                        of_stdout = of_find_node_by_path(name);
+                        of_stdout = of_find_node_opts_by_path(name, &of_stdout_options);
         }
 
         if (!of_aliases)
@@ -1990,7 +2012,8 @@ bool of_console_check(struct device_node *dn, char *name, int index)
 {
         if (!dn || dn != of_stdout || console_set_on_cmdline)
                 return false;
-        return !add_preferred_console(name, index, NULL);
+        return !add_preferred_console(name, index,
+                                      kstrdup(of_stdout_options, GFP_KERNEL));
 }
 EXPORT_SYMBOL_GPL(of_console_check);
 
diff --git a/drivers/of/dynamic.c b/drivers/of/dynamic.c
index d4994177dec2..3351ef408125 100644
--- a/drivers/of/dynamic.c
+++ b/drivers/of/dynamic.c
@@ -77,18 +77,132 @@ int of_reconfig_notifier_unregister(struct notifier_block *nb)
 }
 EXPORT_SYMBOL_GPL(of_reconfig_notifier_unregister);
 
-int of_reconfig_notify(unsigned long action, void *p)
+#ifdef DEBUG
+const char *action_names[] = {
+        [OF_RECONFIG_ATTACH_NODE] = "ATTACH_NODE",
+        [OF_RECONFIG_DETACH_NODE] = "DETACH_NODE",
+        [OF_RECONFIG_ADD_PROPERTY] = "ADD_PROPERTY",
+        [OF_RECONFIG_REMOVE_PROPERTY] = "REMOVE_PROPERTY",
+        [OF_RECONFIG_UPDATE_PROPERTY] = "UPDATE_PROPERTY",
+};
+#endif
+
+int of_reconfig_notify(unsigned long action, struct of_reconfig_data *p)
 {
         int rc;
+#ifdef DEBUG
+        struct of_reconfig_data *pr = p;
+
+        switch (action) {
+        case OF_RECONFIG_ATTACH_NODE:
+        case OF_RECONFIG_DETACH_NODE:
+                pr_debug("of/notify %-15s %s\n", action_names[action],
+                        pr->dn->full_name);
+                break;
+        case OF_RECONFIG_ADD_PROPERTY:
+        case OF_RECONFIG_REMOVE_PROPERTY:
+        case OF_RECONFIG_UPDATE_PROPERTY:
+                pr_debug("of/notify %-15s %s:%s\n", action_names[action],
+                        pr->dn->full_name, pr->prop->name);
+                break;
 
+        }
+#endif
         rc = blocking_notifier_call_chain(&of_reconfig_chain, action, p);
         return notifier_to_errno(rc);
 }
 
+/*
+ * of_reconfig_get_state_change()       - Returns new state of device
+ * @action      - action of the of notifier
+ * @arg         - argument of the of notifier
+ *
+ * Returns the new state of a device based on the notifier used.
+ * Returns 0 on device going from enabled to disabled, 1 on device
+ * going from disabled to enabled and -1 on no change.
+ */
+int of_reconfig_get_state_change(unsigned long action, struct of_reconfig_data *pr)
+{
+        struct property *prop, *old_prop = NULL;
+        int is_status, status_state, old_status_state, prev_state, new_state;
+
+        /* figure out if a device should be created or destroyed */
+        switch (action) {
+        case OF_RECONFIG_ATTACH_NODE:
+        case OF_RECONFIG_DETACH_NODE:
+                prop = of_find_property(pr->dn, "status", NULL);
+                break;
+        case OF_RECONFIG_ADD_PROPERTY:
+        case OF_RECONFIG_REMOVE_PROPERTY:
+                prop = pr->prop;
+                break;
+        case OF_RECONFIG_UPDATE_PROPERTY:
+                prop = pr->prop;
+                old_prop = pr->old_prop;
+                break;
+        default:
+                return OF_RECONFIG_NO_CHANGE;
+        }
+
+        is_status = 0;
+        status_state = -1;
+        old_status_state = -1;
+        prev_state = -1;
+        new_state = -1;
+
+        if (prop && !strcmp(prop->name, "status")) {
+                is_status = 1;
+                status_state = !strcmp(prop->value, "okay") ||
+                               !strcmp(prop->value, "ok");
+                if (old_prop)
+                        old_status_state = !strcmp(old_prop->value, "okay") ||
+                                           !strcmp(old_prop->value, "ok");
+        }
+
+        switch (action) {
+        case OF_RECONFIG_ATTACH_NODE:
+                prev_state = 0;
+                /* -1 & 0 status either missing or okay */
+                new_state = status_state != 0;
+                break;
+        case OF_RECONFIG_DETACH_NODE:
+                /* -1 & 0 status either missing or okay */
+                prev_state = status_state != 0;
+                new_state = 0;
+                break;
+        case OF_RECONFIG_ADD_PROPERTY:
+                if (is_status) {
+                        /* no status property -> enabled (legacy) */
+                        prev_state = 1;
+                        new_state = status_state;
+                }
+                break;
+        case OF_RECONFIG_REMOVE_PROPERTY:
+                if (is_status) {
+                        prev_state = status_state;
+                        /* no status property -> enabled (legacy) */
+                        new_state = 1;
+                }
+                break;
+        case OF_RECONFIG_UPDATE_PROPERTY:
+                if (is_status) {
+                        prev_state = old_status_state != 0;
+                        new_state = status_state != 0;
+                }
+                break;
+        }
+
+        if (prev_state == new_state)
+                return OF_RECONFIG_NO_CHANGE;
+
+        return new_state ? OF_RECONFIG_CHANGE_ADD : OF_RECONFIG_CHANGE_REMOVE;
+}
+EXPORT_SYMBOL_GPL(of_reconfig_get_state_change);
+
 int of_property_notify(int action, struct device_node *np,
                        struct property *prop, struct property *oldprop)
 {
-        struct of_prop_reconfig pr;
+        struct of_reconfig_data pr;
 
         /* only call notifiers if the node is attached */
         if (!of_node_is_attached(np))
@@ -117,8 +231,6 @@ void __of_attach_node(struct device_node *np)
 
         np->child = NULL;
         np->sibling = np->parent->child;
-        np->allnext = np->parent->allnext;
-        np->parent->allnext = np;
         np->parent->child = np;
         of_node_clear_flag(np, OF_DETACHED);
 }
@@ -128,8 +240,12 @@ void __of_attach_node(struct device_node *np)
  */
 int of_attach_node(struct device_node *np)
 {
+        struct of_reconfig_data rd;
         unsigned long flags;
 
+        memset(&rd, 0, sizeof(rd));
+        rd.dn = np;
+
         mutex_lock(&of_mutex);
         raw_spin_lock_irqsave(&devtree_lock, flags);
         __of_attach_node(np);
@@ -138,7 +254,7 @@ int of_attach_node(struct device_node *np)
         __of_attach_node_sysfs(np);
         mutex_unlock(&of_mutex);
 
-        of_reconfig_notify(OF_RECONFIG_ATTACH_NODE, np);
+        of_reconfig_notify(OF_RECONFIG_ATTACH_NODE, &rd);
 
         return 0;
 }
@@ -154,17 +270,6 @@ void __of_detach_node(struct device_node *np)
         if (WARN_ON(!parent))
                 return;
 
-        if (of_allnodes == np)
-                of_allnodes = np->allnext;
-        else {
-                struct device_node *prev;
-                for (prev = of_allnodes;
-                     prev->allnext != np;
-                     prev = prev->allnext)
-                        ;
-                prev->allnext = np->allnext;
-        }
-
         if (parent->child == np)
                 parent->child = np->sibling;
         else {
@@ -187,9 +292,13 @@ void __of_detach_node(struct device_node *np)
  */
 int of_detach_node(struct device_node *np)
 {
+        struct of_reconfig_data rd;
         unsigned long flags;
         int rc = 0;
 
+        memset(&rd, 0, sizeof(rd));
+        rd.dn = np;
+
         mutex_lock(&of_mutex);
         raw_spin_lock_irqsave(&devtree_lock, flags);
         __of_detach_node(np);
@@ -198,7 +307,7 @@ int of_detach_node(struct device_node *np)
         __of_detach_node_sysfs(np);
         mutex_unlock(&of_mutex);
 
-        of_reconfig_notify(OF_RECONFIG_DETACH_NODE, np);
+        of_reconfig_notify(OF_RECONFIG_DETACH_NODE, &rd);
 
         return rc;
 }
@@ -285,36 +394,54 @@ struct property *__of_prop_dup(const struct property *prop, gfp_t allocflags)
 }
 
 /**
- * __of_node_alloc() - Create an empty device node dynamically.
- * @full_name:  Full name of the new device node
- * @allocflags: Allocation flags (typically pass GFP_KERNEL)
+ * __of_node_dup() - Duplicate or create an empty device node dynamically.
+ * @fmt: Format string (plus vargs) for new full name of the device node
  *
- * Create an empty device tree node, suitable for further modification.
- * The node data are dynamically allocated and all the node flags
- * have the OF_DYNAMIC & OF_DETACHED bits set.
- * Returns the newly allocated node or NULL on out of memory error.
+ * Create an device tree node, either by duplicating an empty node or by allocating
+ * an empty one suitable for further modification.  The node data are
+ * dynamically allocated and all the node flags have the OF_DYNAMIC &
+ * OF_DETACHED bits set. Returns the newly allocated node or NULL on out of
+ * memory error.
  */
-struct device_node *__of_node_alloc(const char *full_name, gfp_t allocflags)
+struct device_node *__of_node_dup(const struct device_node *np, const char *fmt, ...)
 {
+        va_list vargs;
         struct device_node *node;
 
-        node = kzalloc(sizeof(*node), allocflags);
+        node = kzalloc(sizeof(*node), GFP_KERNEL);
         if (!node)
                 return NULL;
+        va_start(vargs, fmt);
+        node->full_name = kvasprintf(GFP_KERNEL, fmt, vargs);
+        va_end(vargs);
+        if (!node->full_name) {
+                kfree(node);
+                return NULL;
+        }
 
-        node->full_name = kstrdup(full_name, allocflags);
         of_node_set_flag(node, OF_DYNAMIC);
         of_node_set_flag(node, OF_DETACHED);
-        if (!node->full_name)
-                goto err_free;
-
         of_node_init(node);
 
+        /* Iterate over and duplicate all properties */
+        if (np) {
+                struct property *pp, *new_pp;
+                for_each_property_of_node(np, pp) {
+                        new_pp = __of_prop_dup(pp, GFP_KERNEL);
+                        if (!new_pp)
+                                goto err_prop;
+                        if (__of_add_property(node, new_pp)) {
+                                kfree(new_pp->name);
+                                kfree(new_pp->value);
+                                kfree(new_pp);
+                                goto err_prop;
+                        }
+                }
+        }
         return node;
 
- err_free:
-        kfree(node->full_name);
-        kfree(node);
+ err_prop:
+        of_node_put(node); /* Frees the node and properties */
         return NULL;
 }
 
@@ -330,27 +457,15 @@ static void __of_changeset_entry_dump(struct of_changeset_entry *ce)
 {
         switch (ce->action) {
         case OF_RECONFIG_ADD_PROPERTY:
-                pr_debug("%p: %s %s/%s\n",
-                        ce, "ADD_PROPERTY   ", ce->np->full_name,
-                        ce->prop->name);
-                break;
         case OF_RECONFIG_REMOVE_PROPERTY:
-                pr_debug("%p: %s %s/%s\n",
-                        ce, "REMOVE_PROPERTY", ce->np->full_name,
-                        ce->prop->name);
-                break;
         case OF_RECONFIG_UPDATE_PROPERTY:
-                pr_debug("%p: %s %s/%s\n",
-                        ce, "UPDATE_PROPERTY", ce->np->full_name,
-                        ce->prop->name);
+                pr_debug("of/cset<%p> %-15s %s/%s\n", ce, action_names[ce->action],
+                        ce->np->full_name, ce->prop->name);
                 break;
         case OF_RECONFIG_ATTACH_NODE:
-                pr_debug("%p: %s %s\n",
-                        ce, "ATTACH_NODE    ", ce->np->full_name);
-                break;
         case OF_RECONFIG_DETACH_NODE:
-                pr_debug("%p: %s %s\n",
-                        ce, "DETACH_NODE    ", ce->np->full_name);
+                pr_debug("of/cset<%p> %-15s %s\n", ce, action_names[ce->action],
+                        ce->np->full_name);
                 break;
         }
 }
@@ -388,6 +503,7 @@ static void __of_changeset_entry_invert(struct of_changeset_entry *ce,
 
 static void __of_changeset_entry_notify(struct of_changeset_entry *ce, bool revert)
 {
+        struct of_reconfig_data rd;
         struct of_changeset_entry ce_inverted;
         int ret;
 
@@ -399,7 +515,9 @@ static void __of_changeset_entry_notify(struct of_changeset_entry *ce, bool reve
         switch (ce->action) {
         case OF_RECONFIG_ATTACH_NODE:
         case OF_RECONFIG_DETACH_NODE:
-                ret = of_reconfig_notify(ce->action, ce->np);
+                memset(&rd, 0, sizeof(rd));
+                rd.dn = ce->np;
+                ret = of_reconfig_notify(ce->action, &rd);
                 break;
         case OF_RECONFIG_ADD_PROPERTY:
         case OF_RECONFIG_REMOVE_PROPERTY:
diff --git a/drivers/of/fdt.c b/drivers/of/fdt.c
index d134710de96d..510074226d57 100644
--- a/drivers/of/fdt.c
+++ b/drivers/of/fdt.c
@@ -9,6 +9,7 @@
  * version 2 as published by the Free Software Foundation.
  */
 
+#include <linux/crc32.h>
 #include <linux/kernel.h>
 #include <linux/initrd.h>
 #include <linux/memblock.h>
@@ -22,6 +23,7 @@
 #include <linux/libfdt.h>
 #include <linux/debugfs.h>
 #include <linux/serial_core.h>
+#include <linux/sysfs.h>
 
 #include <asm/setup.h>  /* for COMMAND_LINE_SIZE */
 #include <asm/page.h>
@@ -145,15 +147,15 @@ static void *unflatten_dt_alloc(void **mem, unsigned long size,
  * @mem: Memory chunk to use for allocating device nodes and properties
  * @p: pointer to node in flat tree
  * @dad: Parent struct device_node
- * @allnextpp: pointer to ->allnext from last allocated device_node
  * @fpsize: Size of the node path up at the current depth.
  */
 static void * unflatten_dt_node(void *blob,
                                 void *mem,
                                 int *poffset,
                                 struct device_node *dad,
-                                struct device_node ***allnextpp,
-                                unsigned long fpsize)
+                                struct device_node **nodepp,
+                                unsigned long fpsize,
+                                bool dryrun)
 {
         const __be32 *p;
         struct device_node *np;
@@ -200,7 +202,7 @@ static void * unflatten_dt_node(void *blob,
 
         np = unflatten_dt_alloc(&mem, sizeof(struct device_node) + allocl,
                                 __alignof__(struct device_node));
-        if (allnextpp) {
+        if (!dryrun) {
                 char *fn;
                 of_node_init(np);
                 np->full_name = fn = ((char *)np) + sizeof(*np);
@@ -222,16 +224,10 @@ static void * unflatten_dt_node(void *blob,
                 memcpy(fn, pathp, l);
 
                 prev_pp = &np->properties;
-                **allnextpp = np;
-                *allnextpp = &np->allnext;
                 if (dad != NULL) {
                         np->parent = dad;
-                        /* we temporarily use the next field as `last_child'*/
-                        if (dad->next == NULL)
-                                dad->child = np;
-                        else
-                                dad->next->sibling = np;
-                        dad->next = np;
+                        np->sibling = dad->child;
+                        dad->child = np;
                 }
         }
         /* process properties */
@@ -254,7 +250,7 @@ static void * unflatten_dt_node(void *blob,
                         has_name = 1;
                 pp = unflatten_dt_alloc(&mem, sizeof(struct property),
                                         __alignof__(struct property));
-                if (allnextpp) {
+                if (!dryrun) {
                         /* We accept flattened tree phandles either in
                          * ePAPR-style "phandle" properties, or the
                          * legacy "linux,phandle" properties.  If both
@@ -296,7 +292,7 @@ static void * unflatten_dt_node(void *blob,
                 sz = (pa - ps) + 1;
                 pp = unflatten_dt_alloc(&mem, sizeof(struct property) + sz,
                                         __alignof__(struct property));
-                if (allnextpp) {
+                if (!dryrun) {
                         pp->name = "name";
                         pp->length = sz;
                         pp->value = pp + 1;
@@ -308,7 +304,7 @@ static void * unflatten_dt_node(void *blob,
                                 (char *)pp->value);
                 }
         }
-        if (allnextpp) {
+        if (!dryrun) {
                 *prev_pp = NULL;
                 np->name = of_get_property(np, "name", NULL);
                 np->type = of_get_property(np, "device_type", NULL);
@@ -324,12 +320,30 @@ static void * unflatten_dt_node(void *blob,
         if (depth < 0)
                 depth = 0;
         while (*poffset > 0 && depth > old_depth)
-                mem = unflatten_dt_node(blob, mem, poffset, np, allnextpp,
-                                        fpsize);
+                mem = unflatten_dt_node(blob, mem, poffset, np, NULL,
+                                        fpsize, dryrun);
 
         if (*poffset < 0 && *poffset != -FDT_ERR_NOTFOUND)
                 pr_err("unflatten: error %d processing FDT\n", *poffset);
 
+        /*
+         * Reverse the child list. Some drivers assumes node order matches .dts
+         * node order
+         */
+        if (!dryrun && np->child) {
+                struct device_node *child = np->child;
+                np->child = NULL;
+                while (child) {
+                        struct device_node *next = child->sibling;
+                        child->sibling = np->child;
+                        np->child = child;
+                        child = next;
+                }
+        }
+
+        if (nodepp)
+                *nodepp = np;
+
         return mem;
 }
 
@@ -352,7 +366,6 @@ static void __unflatten_device_tree(void *blob,
         unsigned long size;
         int start;
         void *mem;
-        struct device_node **allnextp = mynodes;
 
         pr_debug(" -> unflatten_device_tree()\n");
 
@@ -373,7 +386,7 @@ static void __unflatten_device_tree(void *blob,
 
         /* First pass, scan for size */
         start = 0;
-        size = (unsigned long)unflatten_dt_node(blob, NULL, &start, NULL, NULL, 0);
+        size = (unsigned long)unflatten_dt_node(blob, NULL, &start, NULL, NULL, 0, true);
         size = ALIGN(size, 4);
 
         pr_debug("  size is %lx, allocating...\n", size);
@@ -388,11 +401,10 @@ static void __unflatten_device_tree(void *blob,
 
         /* Second pass, do actual unflattening */
         start = 0;
-        unflatten_dt_node(blob, mem, &start, NULL, &allnextp, 0);
+        unflatten_dt_node(blob, mem, &start, NULL, mynodes, 0, false);
         if (be32_to_cpup(mem + size) != 0xdeadbeef)
                 pr_warning("End of tree marker overwritten: %08x\n",
                            be32_to_cpup(mem + size));
-        *allnextp = NULL;
 
         pr_debug(" <- unflatten_device_tree()\n");
 }
@@ -425,6 +437,8 @@ void *initial_boot_params;
 
 #ifdef CONFIG_OF_EARLY_FLATTREE
 
+static u32 of_fdt_crc32;
+
 /**
  * res_mem_reserve_reg() - reserve all memory described in 'reg' property
  */
@@ -930,6 +944,11 @@ void __init __weak early_init_dt_add_memory_arch(u64 base, u64 size)
         const u64 phys_offset = __pa(PAGE_OFFSET);
 
         if (!PAGE_ALIGNED(base)) {
+                if (size < PAGE_SIZE - (base & ~PAGE_MASK)) {
+                        pr_warn("Ignoring memory block 0x%llx - 0x%llx\n",
+                                base, base + size);
+                        return;
+                }
                 size -= PAGE_SIZE - (base & ~PAGE_MASK);
                 base = PAGE_ALIGN(base);
         }
@@ -992,15 +1011,14 @@ bool __init early_init_dt_verify(void *params)
         if (!params)
                 return false;
 
-        /* Setup flat device-tree pointer */
-        initial_boot_params = params;
-
         /* check device tree validity */
-        if (fdt_check_header(params)) {
-                initial_boot_params = NULL;
+        if (fdt_check_header(params))
                 return false;
-        }
 
+        /* Setup flat device-tree pointer */
+        initial_boot_params = params;
+        of_fdt_crc32 = crc32_be(~0, initial_boot_params,
+                                fdt_totalsize(initial_boot_params));
         return true;
 }
 
@@ -1039,7 +1057,7 @@ bool __init early_init_dt_scan(void *params)
  */
 void __init unflatten_device_tree(void)
 {
-        __unflatten_device_tree(initial_boot_params, &of_allnodes,
+        __unflatten_device_tree(initial_boot_params, &of_root,
                                 early_init_dt_alloc_memory_arch);
 
         /* Get pointer to "/chosen" and "/aliases" nodes for use everywhere */
@@ -1078,27 +1096,32 @@ void __init unflatten_and_copy_device_tree(void)
         unflatten_device_tree();
 }
 
-#if defined(CONFIG_DEBUG_FS) && defined(DEBUG)
-static struct debugfs_blob_wrapper flat_dt_blob;
-
-static int __init of_flat_dt_debugfs_export_fdt(void)
+#ifdef CONFIG_SYSFS
+static ssize_t of_fdt_raw_read(struct file *filp, struct kobject *kobj,
+                               struct bin_attribute *bin_attr,
+                               char *buf, loff_t off, size_t count)
 {
-        struct dentry *d = debugfs_create_dir("device-tree", NULL);
-
-        if (!d)
-                return -ENOENT;
+        memcpy(buf, initial_boot_params + off, count);
+        return count;
+}
 
-        flat_dt_blob.data = initial_boot_params;
-        flat_dt_blob.size = fdt_totalsize(initial_boot_params);
+static int __init of_fdt_raw_init(void)
+{
+        static struct bin_attribute of_fdt_raw_attr =
+                __BIN_ATTR(fdt, S_IRUSR, of_fdt_raw_read, NULL, 0);
 
-        d = debugfs_create_blob("flat-device-tree", S_IFREG | S_IRUSR,
-                                d, &flat_dt_blob);
-        if (!d)
-                return -ENOENT;
+        if (!initial_boot_params)
+                return 0;
 
-        return 0;
+        if (of_fdt_crc32 != crc32_be(~0, initial_boot_params,
+                                     fdt_totalsize(initial_boot_params))) {
+                pr_warn("fdt: not creating '/sys/firmware/fdt': CRC check failed\n");
+                return 0;
+        }
+        of_fdt_raw_attr.size = fdt_totalsize(initial_boot_params);
+        return sysfs_create_bin_file(firmware_kobj, &of_fdt_raw_attr);
 }
-module_init(of_flat_dt_debugfs_export_fdt);
+late_initcall(of_fdt_raw_init);
 #endif
 
 #endif /* CONFIG_OF_EARLY_FLATTREE */
diff --git a/drivers/of/of_private.h b/drivers/of/of_private.h
index 858e0a5d9a11..8e882e706cd8 100644
--- a/drivers/of/of_private.h
+++ b/drivers/of/of_private.h
@@ -61,7 +61,7 @@ static inline int of_property_notify(int action, struct device_node *np,
  * own the devtree lock or work on detached trees only.
  */
 struct property *__of_prop_dup(const struct property *prop, gfp_t allocflags);
-struct device_node *__of_node_alloc(const char *full_name, gfp_t allocflags);
+__printf(2, 3) struct device_node *__of_node_dup(const struct device_node *np, const char *fmt, ...);
 
 extern const void *__of_get_property(const struct device_node *np,
                                      const char *name, int *lenp);
diff --git a/drivers/of/overlay.c b/drivers/of/overlay.c
new file mode 100644
index 000000000000..ea63fbd228ed
--- /dev/null
+++ b/drivers/of/overlay.c
@@ -0,0 +1,562 @@
+/*
+ * Functions for working with device tree overlays
+ *
+ * Copyright (C) 2012 Pantelis Antoniou <panto@antoniou-consulting.com>
+ * Copyright (C) 2012 Texas Instruments 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.
+ */
+#undef DEBUG
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/of_device.h>
+#include <linux/string.h>
+#include <linux/ctype.h>
+#include <linux/errno.h>
+#include <linux/string.h>
+#include <linux/slab.h>
+#include <linux/err.h>
+
+#include "of_private.h"
+
+/**
+ * struct of_overlay_info - Holds a single overlay info
+ * @target:     target of the overlay operation
+ * @overlay:    pointer to the overlay contents node
+ *
+ * Holds a single overlay state, including all the overlay logs &
+ * records.
+ */
+struct of_overlay_info {
+        struct device_node *target;
+        struct device_node *overlay;
+};
+
+/**
+ * struct of_overlay - Holds a complete overlay transaction
+ * @node:       List on which we are located
+ * @count:      Count of ovinfo structures
+ * @ovinfo_tab: Overlay info table (count sized)
+ * @cset:       Changeset to be used
+ *
+ * Holds a complete overlay transaction
+ */
+struct of_overlay {
+        int id;
+        struct list_head node;
+        int count;
+        struct of_overlay_info *ovinfo_tab;
+        struct of_changeset cset;
+};
+
+static int of_overlay_apply_one(struct of_overlay *ov,
+                struct device_node *target, const struct device_node *overlay);
+
+static int of_overlay_apply_single_property(struct of_overlay *ov,
+                struct device_node *target, struct property *prop)
+{
+        struct property *propn, *tprop;
+
+        /* NOTE: Multiple changes of single properties not supported */
+        tprop = of_find_property(target, prop->name, NULL);
+
+        /* special properties are not meant to be updated (silent NOP) */
+        if (of_prop_cmp(prop->name, "name") == 0 ||
+            of_prop_cmp(prop->name, "phandle") == 0 ||
+            of_prop_cmp(prop->name, "linux,phandle") == 0)
+                return 0;
+
+        propn = __of_prop_dup(prop, GFP_KERNEL);
+        if (propn == NULL)
+                return -ENOMEM;
+
+        /* not found? add */
+        if (tprop == NULL)
+                return of_changeset_add_property(&ov->cset, target, propn);
+
+        /* found? update */
+        return of_changeset_update_property(&ov->cset, target, propn);
+}
+
+static int of_overlay_apply_single_device_node(struct of_overlay *ov,
+                struct device_node *target, struct device_node *child)
+{
+        const char *cname;
+        struct device_node *tchild, *grandchild;
+        int ret = 0;
+
+        cname = kbasename(child->full_name);
+        if (cname == NULL)
+                return -ENOMEM;
+
+        /* NOTE: Multiple mods of created nodes not supported */
+        tchild = of_get_child_by_name(target, cname);
+        if (tchild != NULL) {
+                /* apply overlay recursively */
+                ret = of_overlay_apply_one(ov, tchild, child);
+                of_node_put(tchild);
+        } else {
+                /* create empty tree as a target */
+                tchild = __of_node_dup(child, "%s/%s", target->full_name, cname);
+                if (!tchild)
+                        return -ENOMEM;
+
+                /* point to parent */
+                tchild->parent = target;
+
+                ret = of_changeset_attach_node(&ov->cset, tchild);
+                if (ret)
+                        return ret;
+
+                ret = of_overlay_apply_one(ov, tchild, child);
+                if (ret)
+                        return ret;
+
+                /* The properties are already copied, now do the child nodes */
+                for_each_child_of_node(child, grandchild) {
+                        ret = of_overlay_apply_single_device_node(ov, tchild, grandchild);
+                        if (ret) {
+                                pr_err("%s: Failed to apply single node @%s/%s\n",
+                                        __func__, tchild->full_name,
+                                        grandchild->name);
+                                return ret;
+                        }
+                }
+        }
+
+        return ret;
+}
+
+/*
+ * Apply a single overlay node recursively.
+ *
+ * Note that the in case of an error the target node is left
+ * in a inconsistent state. Error recovery should be performed
+ * by using the changeset.
+ */
+static int of_overlay_apply_one(struct of_overlay *ov,
+                struct device_node *target, const struct device_node *overlay)
+{
+        struct device_node *child;
+        struct property *prop;
+        int ret;
+
+        for_each_property_of_node(overlay, prop) {
+                ret = of_overlay_apply_single_property(ov, target, prop);
+                if (ret) {
+                        pr_err("%s: Failed to apply prop @%s/%s\n",
+                                __func__, target->full_name, prop->name);
+                        return ret;
+                }
+        }
+
+        for_each_child_of_node(overlay, child) {
+                ret = of_overlay_apply_single_device_node(ov, target, child);
+                if (ret != 0) {
+                        pr_err("%s: Failed to apply single node @%s/%s\n",
+                                        __func__, target->full_name,
+                                        child->name);
+                        return ret;
+                }
+        }
+
+        return 0;
+}
+
+/**
+ * of_overlay_apply() - Apply @count overlays pointed at by @ovinfo_tab
+ * @ov:         Overlay to apply
+ *
+ * Applies the overlays given, while handling all error conditions
+ * appropriately. Either the operation succeeds, or if it fails the
+ * live tree is reverted to the state before the attempt.
+ * Returns 0, or an error if the overlay attempt failed.
+ */
+static int of_overlay_apply(struct of_overlay *ov)
+{
+        int i, err;
+
+        /* first we apply the overlays atomically */
+        for (i = 0; i < ov->count; i++) {
+                struct of_overlay_info *ovinfo = &ov->ovinfo_tab[i];
+
+                err = of_overlay_apply_one(ov, ovinfo->target, ovinfo->overlay);
+                if (err != 0) {
+                        pr_err("%s: overlay failed '%s'\n",
+                                __func__, ovinfo->target->full_name);
+                        return err;
+                }
+        }
+
+        return 0;
+}
+
+/*
+ * Find the target node using a number of different strategies
+ * in order of preference
+ *
+ * "target" property containing the phandle of the target
+ * "target-path" property containing the path of the target
+ */
+static struct device_node *find_target_node(struct device_node *info_node)
+{
+        const char *path;
+        u32 val;
+        int ret;
+
+        /* first try to go by using the target as a phandle */
+        ret = of_property_read_u32(info_node, "target", &val);
+        if (ret == 0)
+                return of_find_node_by_phandle(val);
+
+        /* now try to locate by path */
+        ret = of_property_read_string(info_node, "target-path", &path);
+        if (ret == 0)
+                return of_find_node_by_path(path);
+
+        pr_err("%s: Failed to find target for node %p (%s)\n", __func__,
+                info_node, info_node->name);
+
+        return NULL;
+}
+
+/**
+ * of_fill_overlay_info() - Fill an overlay info structure
+ * @ov          Overlay to fill
+ * @info_node:  Device node containing the overlay
+ * @ovinfo:     Pointer to the overlay info structure to fill
+ *
+ * Fills an overlay info structure with the overlay information
+ * from a device node. This device node must have a target property
+ * which contains a phandle of the overlay target node, and an
+ * __overlay__ child node which has the overlay contents.
+ * Both ovinfo->target & ovinfo->overlay have their references taken.
+ *
+ * Returns 0 on success, or a negative error value.
+ */
+static int of_fill_overlay_info(struct of_overlay *ov,
+                struct device_node *info_node, struct of_overlay_info *ovinfo)
+{
+        ovinfo->overlay = of_get_child_by_name(info_node, "__overlay__");
+        if (ovinfo->overlay == NULL)
+                goto err_fail;
+
+        ovinfo->target = find_target_node(info_node);
+        if (ovinfo->target == NULL)
+                goto err_fail;
+
+        return 0;
+
+err_fail:
+        of_node_put(ovinfo->target);
+        of_node_put(ovinfo->overlay);
+
+        memset(ovinfo, 0, sizeof(*ovinfo));
+        return -EINVAL;
+}
+
+/**
+ * of_build_overlay_info() - Build an overlay info array
+ * @ov          Overlay to build
+ * @tree:       Device node containing all the overlays
+ *
+ * Helper function that given a tree containing overlay information,
+ * allocates and builds an overlay info array containing it, ready
+ * for use using of_overlay_apply.
+ *
+ * Returns 0 on success with the @cntp @ovinfop pointers valid,
+ * while on error a negative error value is returned.
+ */
+static int of_build_overlay_info(struct of_overlay *ov,
+                struct device_node *tree)
+{
+        struct device_node *node;
+        struct of_overlay_info *ovinfo;
+        int cnt, err;
+
+        /* worst case; every child is a node */
+        cnt = 0;
+        for_each_child_of_node(tree, node)
+                cnt++;
+
+        ovinfo = kcalloc(cnt, sizeof(*ovinfo), GFP_KERNEL);
+        if (ovinfo == NULL)
+                return -ENOMEM;
+
+        cnt = 0;
+        for_each_child_of_node(tree, node) {
+                memset(&ovinfo[cnt], 0, sizeof(*ovinfo));
+                err = of_fill_overlay_info(ov, node, &ovinfo[cnt]);
+                if (err == 0)
+                        cnt++;
+        }
+
+        /* if nothing filled, return error */
+        if (cnt == 0) {
+                kfree(ovinfo);
+                return -ENODEV;
+        }
+
+        ov->count = cnt;
+        ov->ovinfo_tab = ovinfo;
+
+        return 0;
+}
+
+/**
+ * of_free_overlay_info() - Free an overlay info array
+ * @ov          Overlay to free the overlay info from
+ * @ovinfo_tab: Array of overlay_info's to free
+ *
+ * Releases the memory of a previously allocated ovinfo array
+ * by of_build_overlay_info.
+ * Returns 0, or an error if the arguments are bogus.
+ */
+static int of_free_overlay_info(struct of_overlay *ov)
+{
+        struct of_overlay_info *ovinfo;
+        int i;
+
+        /* do it in reverse */
+        for (i = ov->count - 1; i >= 0; i--) {
+                ovinfo = &ov->ovinfo_tab[i];
+
+                of_node_put(ovinfo->target);
+                of_node_put(ovinfo->overlay);
+        }
+        kfree(ov->ovinfo_tab);
+
+        return 0;
+}
+
+static LIST_HEAD(ov_list);
+static DEFINE_IDR(ov_idr);
+
+/**
+ * of_overlay_create() - Create and apply an overlay
+ * @tree:       Device node containing all the overlays
+ *
+ * Creates and applies an overlay while also keeping track
+ * of the overlay in a list. This list can be used to prevent
+ * illegal overlay removals.
+ *
+ * Returns the id of the created overlay, or an negative error number
+ */
+int of_overlay_create(struct device_node *tree)
+{
+        struct of_overlay *ov;
+        int err, id;
+
+        /* allocate the overlay structure */
+        ov = kzalloc(sizeof(*ov), GFP_KERNEL);
+        if (ov == NULL)
+                return -ENOMEM;
+        ov->id = -1;
+
+        INIT_LIST_HEAD(&ov->node);
+
+        of_changeset_init(&ov->cset);
+
+        mutex_lock(&of_mutex);
+
+        id = idr_alloc(&ov_idr, ov, 0, 0, GFP_KERNEL);
+        if (id < 0) {
+                pr_err("%s: idr_alloc() failed for tree@%s\n",
+                                __func__, tree->full_name);
+                err = id;
+                goto err_destroy_trans;
+        }
+        ov->id = id;
+
+        /* build the overlay info structures */
+        err = of_build_overlay_info(ov, tree);
+        if (err) {
+                pr_err("%s: of_build_overlay_info() failed for tree@%s\n",
+                                __func__, tree->full_name);
+                goto err_free_idr;
+        }
+
+        /* apply the overlay */
+        err = of_overlay_apply(ov);
+        if (err) {
+                pr_err("%s: of_overlay_apply() failed for tree@%s\n",
+                                __func__, tree->full_name);
+                goto err_abort_trans;
+        }
+
+        /* apply the changeset */
+        err = of_changeset_apply(&ov->cset);
+        if (err) {
+                pr_err("%s: of_changeset_apply() failed for tree@%s\n",
+                                __func__, tree->full_name);
+                goto err_revert_overlay;
+        }
+
+        /* add to the tail of the overlay list */
+        list_add_tail(&ov->node, &ov_list);
+
+        mutex_unlock(&of_mutex);
+
+        return id;
+
+err_revert_overlay:
+err_abort_trans:
+        of_free_overlay_info(ov);
+err_free_idr:
+        idr_remove(&ov_idr, ov->id);
+err_destroy_trans:
+        of_changeset_destroy(&ov->cset);
+        kfree(ov);
+        mutex_unlock(&of_mutex);
+
+        return err;
+}
+EXPORT_SYMBOL_GPL(of_overlay_create);
+
+/* check whether the given node, lies under the given tree */
+static int overlay_subtree_check(struct device_node *tree,
+                struct device_node *dn)
+{
+        struct device_node *child;
+
+        /* match? */
+        if (tree == dn)
+                return 1;
+
+        for_each_child_of_node(tree, child) {
+                if (overlay_subtree_check(child, dn))
+                        return 1;
+        }
+
+        return 0;
+}
+
+/* check whether this overlay is the topmost */
+static int overlay_is_topmost(struct of_overlay *ov, struct device_node *dn)
+{
+        struct of_overlay *ovt;
+        struct of_changeset_entry *ce;
+
+        list_for_each_entry_reverse(ovt, &ov_list, node) {
+                /* if we hit ourselves, we're done */
+                if (ovt == ov)
+                        break;
+
+                /* check against each subtree affected by this overlay */
+                list_for_each_entry(ce, &ovt->cset.entries, node) {
+                        if (overlay_subtree_check(ce->np, dn)) {
+                                pr_err("%s: #%d clashes #%d @%s\n",
+                                        __func__, ov->id, ovt->id,
+                                        dn->full_name);
+                                return 0;
+                        }
+                }
+        }
+
+        /* overlay is topmost */
+        return 1;
+}
+
+/*
+ * We can safely remove the overlay only if it's the top-most one.
+ * Newly applied overlays are inserted at the tail of the overlay list,
+ * so a top most overlay is the one that is closest to the tail.
+ *
+ * The topmost check is done by exploiting this property. For each
+ * affected device node in the log list we check if this overlay is
+ * the one closest to the tail. If another overlay has affected this
+ * device node and is closest to the tail, then removal is not permited.
+ */
+static int overlay_removal_is_ok(struct of_overlay *ov)
+{
+        struct of_changeset_entry *ce;
+
+        list_for_each_entry(ce, &ov->cset.entries, node) {
+                if (!overlay_is_topmost(ov, ce->np)) {
+                        pr_err("%s: overlay #%d is not topmost\n",
+                                        __func__, ov->id);
+                        return 0;
+                }
+        }
+
+        return 1;
+}
+
+/**
+ * of_overlay_destroy() - Removes an overlay
+ * @id: Overlay id number returned by a previous call to of_overlay_create
+ *
+ * Removes an overlay if it is permissible.
+ *
+ * Returns 0 on success, or an negative error number
+ */
+int of_overlay_destroy(int id)
+{
+        struct of_overlay *ov;
+        int err;
+
+        mutex_lock(&of_mutex);
+
+        ov = idr_find(&ov_idr, id);
+        if (ov == NULL) {
+                err = -ENODEV;
+                pr_err("%s: Could not find overlay #%d\n",
+                                __func__, id);
+                goto out;
+        }
+
+        /* check whether the overlay is safe to remove */
+        if (!overlay_removal_is_ok(ov)) {
+                err = -EBUSY;
+                pr_err("%s: removal check failed for overlay #%d\n",
+                                __func__, id);
+                goto out;
+        }
+
+
+        list_del(&ov->node);
+        of_changeset_revert(&ov->cset);
+        of_free_overlay_info(ov);
+        idr_remove(&ov_idr, id);
+        of_changeset_destroy(&ov->cset);
+        kfree(ov);
+
+        err = 0;
+
+out:
+        mutex_unlock(&of_mutex);
+
+        return err;
+}
+EXPORT_SYMBOL_GPL(of_overlay_destroy);
+
+/**
+ * of_overlay_destroy_all() - Removes all overlays from the system
+ *
+ * Removes all overlays from the system in the correct order.
+ *
+ * Returns 0 on success, or an negative error number
+ */
+int of_overlay_destroy_all(void)
+{
+        struct of_overlay *ov, *ovn;
+
+        mutex_lock(&of_mutex);
+
+        /* the tail of list is guaranteed to be safe to remove */
+        list_for_each_entry_safe_reverse(ov, ovn, &ov_list, node) {
+                list_del(&ov->node);
+                of_changeset_revert(&ov->cset);
+                of_free_overlay_info(ov);
+                idr_remove(&ov_idr, ov->id);
+                kfree(ov);
+        }
+
+        mutex_unlock(&of_mutex);
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(of_overlay_destroy_all);
diff --git a/drivers/of/pdt.c b/drivers/of/pdt.c
index 36b4035881b0..d2acae825af9 100644
--- a/drivers/of/pdt.c
+++ b/drivers/of/pdt.c
@@ -25,8 +25,7 @@
 
 static struct of_pdt_ops *of_pdt_prom_ops __initdata;
 
-void __initdata (*of_pdt_build_more)(struct device_node *dp,
-                struct device_node ***nextp);
+void __initdata (*of_pdt_build_more)(struct device_node *dp);
 
 #if defined(CONFIG_SPARC)
 unsigned int of_pdt_unique_id __initdata;
@@ -192,8 +191,7 @@ static struct device_node * __init of_pdt_create_node(phandle node,
 }
 
 static struct device_node * __init of_pdt_build_tree(struct device_node *parent,
-                                                   phandle node,
-                                                   struct device_node ***nextp)
+                                                   phandle node)
 {
         struct device_node *ret = NULL, *prev_sibling = NULL;
         struct device_node *dp;
@@ -210,16 +208,12 @@ static struct device_node * __init of_pdt_build_tree(struct device_node *parent,
                         ret = dp;
                 prev_sibling = dp;
 
-                *(*nextp) = dp;
-                *nextp = &dp->allnext;
-
                 dp->full_name = of_pdt_build_full_name(dp);
 
-                dp->child = of_pdt_build_tree(dp,
-                                of_pdt_prom_ops->getchild(node), nextp);
+                dp->child = of_pdt_build_tree(dp, of_pdt_prom_ops->getchild(node));
 
                 if (of_pdt_build_more)
-                        of_pdt_build_more(dp, nextp);
+                        of_pdt_build_more(dp);
 
                 node = of_pdt_prom_ops->getsibling(node);
         }
@@ -234,20 +228,17 @@ static void * __init kernel_tree_alloc(u64 size, u64 align)
 
 void __init of_pdt_build_devicetree(phandle root_node, struct of_pdt_ops *ops)
 {
-        struct device_node **nextp;
-
         BUG_ON(!ops);
         of_pdt_prom_ops = ops;
 
-        of_allnodes = of_pdt_create_node(root_node, NULL);
+        of_root = of_pdt_create_node(root_node, NULL);
 #if defined(CONFIG_SPARC)
-        of_allnodes->path_component_name = "";
+        of_root->path_component_name = "";
 #endif
-        of_allnodes->full_name = "/";
+        of_root->full_name = "/";
 
-        nextp = &of_allnodes->allnext;
-        of_allnodes->child = of_pdt_build_tree(of_allnodes,
-                        of_pdt_prom_ops->getchild(of_allnodes->phandle), &nextp);
+        of_root->child = of_pdt_build_tree(of_root,
+                                of_pdt_prom_ops->getchild(of_root->phandle));
 
         /* Get pointer to "/chosen" and "/aliases" nodes for use everywhere */
         of_alias_scan(kernel_tree_alloc);
diff --git a/drivers/of/platform.c b/drivers/of/platform.c
index 3b64d0bf5bba..cd87a36495be 100644
--- a/drivers/of/platform.c
+++ b/drivers/of/platform.c
@@ -138,7 +138,7 @@ struct platform_device *of_device_alloc(struct device_node *np,
         }
 
         dev->dev.of_node = of_node_get(np);
-        dev->dev.parent = parent;
+        dev->dev.parent = parent ? : &platform_bus;
 
         if (bus_id)
                 dev_set_name(&dev->dev, "%s", bus_id);
@@ -291,7 +291,7 @@ static struct amba_device *of_amba_device_create(struct device_node *node,
 
         /* setup generic device info */
         dev->dev.of_node = of_node_get(node);
-        dev->dev.parent = parent;
+        dev->dev.parent = parent ? : &platform_bus;
         dev->dev.platform_data = platform_data;
         if (bus_id)
                 dev_set_name(&dev->dev, "%s", bus_id);
@@ -500,6 +500,7 @@ int of_platform_populate(struct device_node *root,
                 if (rc)
                         break;
         }
+        of_node_set_flag(root, OF_POPULATED_BUS);
 
         of_node_put(root);
         return rc;
@@ -542,8 +543,66 @@ static int of_platform_device_destroy(struct device *dev, void *data)
  */
 void of_platform_depopulate(struct device *parent)
 {
-        device_for_each_child(parent, NULL, of_platform_device_destroy);
+        if (parent->of_node && of_node_check_flag(parent->of_node, OF_POPULATED_BUS)) {
+                device_for_each_child(parent, NULL, of_platform_device_destroy);
+                of_node_clear_flag(parent->of_node, OF_POPULATED_BUS);
+        }
 }
 EXPORT_SYMBOL_GPL(of_platform_depopulate);
 
+#ifdef CONFIG_OF_DYNAMIC
+static int of_platform_notify(struct notifier_block *nb,
+                                unsigned long action, void *arg)
+{
+        struct of_reconfig_data *rd = arg;
+        struct platform_device *pdev_parent, *pdev;
+        bool children_left;
+
+        switch (of_reconfig_get_state_change(action, rd)) {
+        case OF_RECONFIG_CHANGE_ADD:
+                /* verify that the parent is a bus */
+                if (!of_node_check_flag(rd->dn->parent, OF_POPULATED_BUS))
+                        return NOTIFY_OK;       /* not for us */
+
+                /* pdev_parent may be NULL when no bus platform device */
+                pdev_parent = of_find_device_by_node(rd->dn->parent);
+                pdev = of_platform_device_create(rd->dn, NULL,
+                                pdev_parent ? &pdev_parent->dev : NULL);
+                of_dev_put(pdev_parent);
+
+                if (pdev == NULL) {
+                        pr_err("%s: failed to create for '%s'\n",
+                                        __func__, rd->dn->full_name);
+                        /* of_platform_device_create tosses the error code */
+                        return notifier_from_errno(-EINVAL);
+                }
+                break;
+
+        case OF_RECONFIG_CHANGE_REMOVE:
+                /* find our device by node */
+                pdev = of_find_device_by_node(rd->dn);
+                if (pdev == NULL)
+                        return NOTIFY_OK;       /* no? not meant for us */
+
+                /* unregister takes one ref away */
+                of_platform_device_destroy(&pdev->dev, &children_left);
+
+                /* and put the reference of the find */
+                of_dev_put(pdev);
+                break;
+        }
+
+        return NOTIFY_OK;
+}
+
+static struct notifier_block platform_of_notifier = {
+        .notifier_call = of_platform_notify,
+};
+
+void of_platform_register_reconfig_notifier(void)
+{
+        WARN_ON(of_reconfig_notifier_register(&platform_of_notifier));
+}
+#endif /* CONFIG_OF_DYNAMIC */
+
 #endif /* CONFIG_OF_ADDRESS */
diff --git a/drivers/of/resolver.c b/drivers/of/resolver.c
index aed7959f800d..640eb4cb46e3 100644
--- a/drivers/of/resolver.c
+++ b/drivers/of/resolver.c
@@ -111,7 +111,8 @@ static void __of_adjust_tree_phandles(struct device_node *node,
                 __of_adjust_tree_phandles(child, phandle_delta);
 }
 
-static int __of_adjust_phandle_ref(struct device_node *node, struct property *rprop, int value, bool is_delta)
+static int __of_adjust_phandle_ref(struct device_node *node,
+                struct property *rprop, int value)
 {
         phandle phandle;
         struct device_node *refnode;
@@ -181,7 +182,7 @@ static int __of_adjust_phandle_ref(struct device_node *node, struct property *rp
                         goto err_fail;
                 }
 
-                phandle = is_delta ? be32_to_cpup(sprop->value + offset) + value : value;
+                phandle = value;
                 *(__be32 *)(sprop->value + offset) = cpu_to_be32(phandle);
         }
 
@@ -190,36 +191,97 @@ err_fail:
         return err;
 }
 
+/* compare nodes taking into account that 'name' strips out the @ part */
+static int __of_node_name_cmp(const struct device_node *dn1,
+                const struct device_node *dn2)
+{
+        const char *n1 = strrchr(dn1->full_name, '/') ? : "/";
+        const char *n2 = strrchr(dn2->full_name, '/') ? : "/";
+
+        return of_node_cmp(n1, n2);
+}
+
 /*
  * Adjust the local phandle references by the given phandle delta.
- * Assumes the existances of a __local_fixups__ node at the root
- * of the tree. Does not take any devtree locks so make sure you
- * call this on a tree which is at the detached state.
+ * Assumes the existances of a __local_fixups__ node at the root.
+ * Assumes that __of_verify_tree_phandle_references has been called.
+ * Does not take any devtree locks so make sure you call this on a tree
+ * which is at the detached state.
  */
 static int __of_adjust_tree_phandle_references(struct device_node *node,
-                int phandle_delta)
+                struct device_node *target, int phandle_delta)
 {
-        struct device_node *child;
-        struct property *rprop;
-        int err;
-
-        /* locate the symbols & fixups nodes on resolve */
-        for_each_child_of_node(node, child)
-                if (of_node_cmp(child->name, "__local_fixups__") == 0)
-                        break;
+        struct device_node *child, *childtarget;
+        struct property *rprop, *sprop;
+        int err, i, count;
+        unsigned int off;
+        phandle phandle;
 
-        /* no local fixups */
-        if (!child)
+        if (node == NULL)
                 return 0;
 
-        /* find the local fixups property */
-        for_each_property_of_node(child, rprop) {
+        for_each_property_of_node(node, rprop) {
+
                 /* skip properties added automatically */
-                if (of_prop_cmp(rprop->name, "name") == 0)
+                if (of_prop_cmp(rprop->name, "name") == 0 ||
+                    of_prop_cmp(rprop->name, "phandle") == 0 ||
+                    of_prop_cmp(rprop->name, "linux,phandle") == 0)
                         continue;
 
-                err = __of_adjust_phandle_ref(node, rprop, phandle_delta, true);
-                if (err)
+                if ((rprop->length % 4) != 0 || rprop->length == 0) {
+                        pr_err("%s: Illegal property (size) '%s' @%s\n",
+                                        __func__, rprop->name, node->full_name);
+                        return -EINVAL;
+                }
+                count = rprop->length / sizeof(__be32);
+
+                /* now find the target property */
+                for_each_property_of_node(target, sprop) {
+                        if (of_prop_cmp(sprop->name, rprop->name) == 0)
+                                break;
+                }
+
+                if (sprop == NULL) {
+                        pr_err("%s: Could not find target property '%s' @%s\n",
+                                        __func__, rprop->name, node->full_name);
+                        return -EINVAL;
+                }
+
+                for (i = 0; i < count; i++) {
+                        off = be32_to_cpu(((__be32 *)rprop->value)[i]);
+                        /* make sure the offset doesn't overstep (even wrap) */
+                        if (off >= sprop->length ||
+                                        (off + 4) > sprop->length) {
+                                pr_err("%s: Illegal property '%s' @%s\n",
+                                                __func__, rprop->name,
+                                                node->full_name);
+                                return -EINVAL;
+                        }
+
+                        if (phandle_delta) {
+                                /* adjust */
+                                phandle = be32_to_cpu(*(__be32 *)(sprop->value + off));
+                                phandle += phandle_delta;
+                                *(__be32 *)(sprop->value + off) = cpu_to_be32(phandle);
+                        }
+                }
+        }
+
+        for_each_child_of_node(node, child) {
+
+                for_each_child_of_node(target, childtarget)
+                        if (__of_node_name_cmp(child, childtarget) == 0)
+                                break;
+
+                if (!childtarget) {
+                        pr_err("%s: Could not find target child '%s' @%s\n",
+                                        __func__, child->name, node->full_name);
+                        return -EINVAL;
+                }
+
+                err = __of_adjust_tree_phandle_references(child, childtarget,
+                                phandle_delta);
+                if (err != 0)
                         return err;
         }
 
@@ -241,7 +303,7 @@ static int __of_adjust_tree_phandle_references(struct device_node *node,
  */
 int of_resolve_phandles(struct device_node *resolve)
 {
-        struct device_node *child, *refnode;
+        struct device_node *child, *childroot, *refnode;
         struct device_node *root_sym, *resolve_sym, *resolve_fix;
         struct property *rprop;
         const char *refpath;
@@ -255,9 +317,23 @@ int of_resolve_phandles(struct device_node *resolve)
         /* first we need to adjust the phandles */
         phandle_delta = of_get_tree_max_phandle() + 1;
         __of_adjust_tree_phandles(resolve, phandle_delta);
-        err = __of_adjust_tree_phandle_references(resolve, phandle_delta);
-        if (err != 0)
-                return err;
+
+        /* locate the local fixups */
+        childroot = NULL;
+        for_each_child_of_node(resolve, childroot)
+                if (of_node_cmp(childroot->name, "__local_fixups__") == 0)
+                        break;
+
+        if (childroot != NULL) {
+                /* resolve root is guaranteed to be the '/' */
+                err = __of_adjust_tree_phandle_references(childroot,
+                                resolve, 0);
+                if (err != 0)
+                        return err;
+
+                BUG_ON(__of_adjust_tree_phandle_references(childroot,
+                                resolve, phandle_delta));
+        }
 
         root_sym = NULL;
         resolve_sym = NULL;
@@ -322,7 +398,7 @@ int of_resolve_phandles(struct device_node *resolve)
                 pr_debug("%s: %s phandle is 0x%08x\n",
                                 __func__, rprop->name, phandle);
 
-                err = __of_adjust_phandle_ref(resolve, rprop, phandle, false);
+                err = __of_adjust_phandle_ref(resolve, rprop, phandle);
                 if (err)
                         break;
         }
diff --git a/drivers/of/testcase-data/testcases.dts b/drivers/of/testcase-data/testcases.dts
deleted file mode 100644
index 6994e15c24bf..000000000000
--- a/drivers/of/testcase-data/testcases.dts
+++ /dev/null
@@ -1,50 +0,0 @@
-/dts-v1/;
-/ {
-        testcase-data {
-                changeset {
-                        prop-update = "hello";
-                        prop-remove = "world";
-                        node-remove {
-                        };
-                };
-        };
-};
-#include "tests-phandle.dtsi"
-#include "tests-interrupts.dtsi"
-#include "tests-match.dtsi"
-#include "tests-platform.dtsi"
-
-/*
- * phandle fixup data - generated by dtc patches that aren't upstream.
- * This data must be regenerated whenever phandle references are modified in
- * the testdata tree.
- *
- * The format of this data may be subject to change. For the time being consider
- * this a kernel-internal data format.
- */
-/ { __local_fixups__ {
-        fixup = "/testcase-data/testcase-device2:interrupt-parent:0",
-                "/testcase-data/testcase-device1:interrupt-parent:0",
-                "/testcase-data/interrupts/interrupts-extended0:interrupts-extended:60",
-                "/testcase-data/interrupts/interrupts-extended0:interrupts-extended:52",
-                "/testcase-data/interrupts/interrupts-extended0:interrupts-extended:44",
-                "/testcase-data/interrupts/interrupts-extended0:interrupts-extended:36",
-                "/testcase-data/interrupts/interrupts-extended0:interrupts-extended:24",
-                "/testcase-data/interrupts/interrupts-extended0:interrupts-extended:8",
-                "/testcase-data/interrupts/interrupts-extended0:interrupts-extended:0",
-                "/testcase-data/interrupts/interrupts1:interrupt-parent:0",
-                "/testcase-data/interrupts/interrupts0:interrupt-parent:0",
-                "/testcase-data/interrupts/intmap1:interrupt-map:12",
-                "/testcase-data/interrupts/intmap0:interrupt-map:52",
-                "/testcase-data/interrupts/intmap0:interrupt-map:36",
-                "/testcase-data/interrupts/intmap0:interrupt-map:16",
-                "/testcase-data/interrupts/intmap0:interrupt-map:4",
-                "/testcase-data/phandle-tests/consumer-a:phandle-list-bad-args:12",
-                "/testcase-data/phandle-tests/consumer-a:phandle-list-bad-args:0",
-                "/testcase-data/phandle-tests/consumer-a:phandle-list:56",
-                "/testcase-data/phandle-tests/consumer-a:phandle-list:52",
-                "/testcase-data/phandle-tests/consumer-a:phandle-list:40",
-                "/testcase-data/phandle-tests/consumer-a:phandle-list:24",
-                "/testcase-data/phandle-tests/consumer-a:phandle-list:8",
-                "/testcase-data/phandle-tests/consumer-a:phandle-list:0";
-}; };
diff --git a/drivers/of/unittest-data/testcases.dts b/drivers/of/unittest-data/testcases.dts
new file mode 100644
index 000000000000..12f7c3d649c8
--- /dev/null
+++ b/drivers/of/unittest-data/testcases.dts
@@ -0,0 +1,79 @@
+/dts-v1/;
+/ {
+        testcase-data {
+                changeset {
+                        prop-update = "hello";
+                        prop-remove = "world";
+                        node-remove {
+                        };
+                };
+        };
+};
+#include "tests-phandle.dtsi"
+#include "tests-interrupts.dtsi"
+#include "tests-match.dtsi"
+#include "tests-platform.dtsi"
+#include "tests-overlay.dtsi"
+
+/*
+ * phandle fixup data - generated by dtc patches that aren't upstream.
+ * This data must be regenerated whenever phandle references are modified in
+ * the testdata tree.
+ *
+ * The format of this data may be subject to change. For the time being consider
+ * this a kernel-internal data format.
+ */
+/ { __local_fixups__ {
+        testcase-data {
+                phandle-tests {
+                        consumer-a {
+                                phandle-list = <0x00000000 0x00000008
+                                                0x00000018 0x00000028
+                                                0x00000034 0x00000038>;
+                                phandle-list-bad-args = <0x00000000 0x0000000c>;
+                        };
+                };
+                interrupts {
+                        intmap0 {
+                                interrupt-map = <0x00000004 0x00000010
+                                                 0x00000024 0x00000034>;
+                        };
+                        intmap1 {
+                                interrupt-map = <0x0000000c>;
+                        };
+                        interrupts0 {
+                                interrupt-parent = <0x00000000>;
+                        };
+                        interrupts1 {
+                                interrupt-parent = <0x00000000>;
+                        };
+                        interrupts-extended0 {
+                                interrupts-extended = <0x00000000 0x00000008
+                                                       0x00000018 0x00000024
+                                                       0x0000002c 0x00000034
+                                                       0x0000003c>;
+                        };
+                };
+                testcase-device1 {
+                        interrupt-parent = <0x00000000>;
+                };
+                testcase-device2 {
+                        interrupt-parent = <0x00000000>;
+                };
+                overlay2 {
+                        fragment@0 {
+                                target = <0x00000000>;
+                        };
+                };
+                overlay3 {
+                        fragment@0 {
+                                target = <0x00000000>;
+                        };
+                };
+                overlay4 {
+                        fragment@0 {
+                                target = <0x00000000>;
+                        };
+                };
+        };
+}; };
diff --git a/drivers/of/testcase-data/tests-interrupts.dtsi b/drivers/of/unittest-data/tests-interrupts.dtsi
index da4695f60351..da4695f60351 100644
--- a/drivers/of/testcase-data/tests-interrupts.dtsi
+++ b/drivers/of/unittest-data/tests-interrupts.dtsi
diff --git a/drivers/of/testcase-data/tests-match.dtsi b/drivers/of/unittest-data/tests-match.dtsi
index c9e541129534..c9e541129534 100644
--- a/drivers/of/testcase-data/tests-match.dtsi
+++ b/drivers/of/unittest-data/tests-match.dtsi
diff --git a/drivers/of/unittest-data/tests-overlay.dtsi b/drivers/of/unittest-data/tests-overlay.dtsi
new file mode 100644
index 000000000000..75976da22b2e
--- /dev/null
+++ b/drivers/of/unittest-data/tests-overlay.dtsi
@@ -0,0 +1,180 @@
+
+/ {
+        testcase-data {
+                overlay-node {
+
+                        /* test bus */
+                        selftestbus: test-bus {
+                                compatible = "simple-bus";
+                                #address-cells = <1>;
+                                #size-cells = <0>;
+
+                                selftest100: test-selftest100 {
+                                        compatible = "selftest";
+                                        status = "okay";
+                                        reg = <100>;
+                                };
+
+                                selftest101: test-selftest101 {
+                                        compatible = "selftest";
+                                        status = "disabled";
+                                        reg = <101>;
+                                };
+
+                                selftest0: test-selftest0 {
+                                        compatible = "selftest";
+                                        status = "disabled";
+                                        reg = <0>;
+                                };
+
+                                selftest1: test-selftest1 {
+                                        compatible = "selftest";
+                                        status = "okay";
+                                        reg = <1>;
+                                };
+
+                                selftest2: test-selftest2 {
+                                        compatible = "selftest";
+                                        status = "disabled";
+                                        reg = <2>;
+                                };
+
+                                selftest3: test-selftest3 {
+                                        compatible = "selftest";
+                                        status = "okay";
+                                        reg = <3>;
+                                };
+
+                                selftest5: test-selftest5 {
+                                        compatible = "selftest";
+                                        status = "disabled";
+                                        reg = <5>;
+                                };
+
+                                selftest6: test-selftest6 {
+                                        compatible = "selftest";
+                                        status = "disabled";
+                                        reg = <6>;
+                                };
+
+                                selftest7: test-selftest7 {
+                                        compatible = "selftest";
+                                        status = "disabled";
+                                        reg = <7>;
+                                };
+
+                                selftest8: test-selftest8 {
+                                        compatible = "selftest";
+                                        status = "disabled";
+                                        reg = <8>;
+                                };
+                        };
+                };
+
+                /* test enable using absolute target path */
+                overlay0 {
+                        fragment@0 {
+                                target-path = "/testcase-data/overlay-node/test-bus/test-selftest0";
+                                __overlay__ {
+                                        status = "okay";
+                                };
+                        };
+                };
+
+                /* test disable using absolute target path */
+                overlay1 {
+                        fragment@0 {
+                                target-path = "/testcase-data/overlay-node/test-bus/test-selftest1";
+                                __overlay__ {
+                                        status = "disabled";
+                                };
+                        };
+                };
+
+                /* test enable using label */
+                overlay2 {
+                        fragment@0 {
+                                target = <&selftest2>;
+                                __overlay__ {
+                                        status = "okay";
+                                };
+                        };
+                };
+
+                /* test disable using label */
+                overlay3 {
+                        fragment@0 {
+                                target = <&selftest3>;
+                                __overlay__ {
+                                        status = "disabled";
+                                };
+                        };
+                };
+
+                /* test insertion of a full node */
+                overlay4 {
+                        fragment@0 {
+                                target = <&selftestbus>;
+                                __overlay__ {
+
+                                        /* suppress DTC warning */
+                                        #address-cells = <1>;
+                                        #size-cells = <0>;
+
+                                        test-selftest4 {
+                                                compatible = "selftest";
+                                                status = "okay";
+                                                reg = <4>;
+                                        };
+                                };
+                        };
+                };
+
+                /* test overlay apply revert */
+                overlay5 {
+                        fragment@0 {
+                                target-path = "/testcase-data/overlay-node/test-bus/test-selftest5";
+                                __overlay__ {
+                                        status = "okay";
+                                };
+                        };
+                };
+
+                /* test overlays application and removal in sequence */
+                overlay6 {
+                        fragment@0 {
+                                target-path = "/testcase-data/overlay-node/test-bus/test-selftest6";
+                                __overlay__ {
+                                        status = "okay";
+                                };
+                        };
+                };
+                overlay7 {
+                        fragment@0 {
+                                target-path = "/testcase-data/overlay-node/test-bus/test-selftest7";
+                                __overlay__ {
+                                        status = "okay";
+                                };
+                        };
+                };
+
+                /* test overlays application and removal in bad sequence */
+                overlay8 {
+                        fragment@0 {
+                                target-path = "/testcase-data/overlay-node/test-bus/test-selftest8";
+                                __overlay__ {
+                                        status = "okay";
+                                };
+                        };
+                };
+                overlay9 {
+                        fragment@0 {
+                                target-path = "/testcase-data/overlay-node/test-bus/test-selftest8";
+                                __overlay__ {
+                                        property-foo = "bar";
+                                };
+                        };
+                };
+
+        };
+};
diff --git a/drivers/of/testcase-data/tests-phandle.dtsi b/drivers/of/unittest-data/tests-phandle.dtsi
index 5b1527e8a7fb..5b1527e8a7fb 100644
--- a/drivers/of/testcase-data/tests-phandle.dtsi
+++ b/drivers/of/unittest-data/tests-phandle.dtsi
diff --git a/drivers/of/testcase-data/tests-platform.dtsi b/drivers/of/unittest-data/tests-platform.dtsi
index eb20eeb2b062..eb20eeb2b062 100644
--- a/drivers/of/testcase-data/tests-platform.dtsi
+++ b/drivers/of/unittest-data/tests-platform.dtsi
diff --git a/drivers/of/selftest.c b/drivers/of/unittest.c
index e2d79afa9dc6..844838e11ef1 100644
--- a/drivers/of/selftest.c
+++ b/drivers/of/unittest.c
@@ -17,6 +17,8 @@
 #include <linux/mutex.h>
 #include <linux/slab.h>
 #include <linux/device.h>
+#include <linux/platform_device.h>
+#include <linux/of_platform.h>
 
 #include "of_private.h"
 
@@ -30,19 +32,22 @@ static struct device_node *nodes[NO_OF_NODES];
 static int last_node_index;
 static bool selftest_live_tree;
 
-#define selftest(result, fmt, ...) { \
-        if (!(result)) { \
+#define selftest(result, fmt, ...) ({ \
+        bool failed = !(result); \
+        if (failed) { \
                 selftest_results.failed++; \
                 pr_err("FAIL %s():%i " fmt, __func__, __LINE__, ##__VA_ARGS__); \
         } else { \
                 selftest_results.passed++; \
                 pr_debug("pass %s():%i\n", __func__, __LINE__); \
         } \
-}
+        failed; \
+})
 
 static void __init of_selftest_find_node_by_name(void)
 {
         struct device_node *np;
+        const char *options;
 
         np = of_find_node_by_path("/testcase-data");
         selftest(np && !strcmp("/testcase-data", np->full_name),
@@ -83,6 +88,35 @@ static void __init of_selftest_find_node_by_name(void)
         np = of_find_node_by_path("testcase-alias/missing-path");
         selftest(!np, "non-existent alias with relative path returned node %s\n", np->full_name);
         of_node_put(np);
+
+        np = of_find_node_opts_by_path("/testcase-data:testoption", &options);
+        selftest(np && !strcmp("testoption", options),
+                 "option path test failed\n");
+        of_node_put(np);
+
+        np = of_find_node_opts_by_path("/testcase-data:testoption", NULL);
+        selftest(np, "NULL option path test failed\n");
+        of_node_put(np);
+
+        np = of_find_node_opts_by_path("testcase-alias:testaliasoption",
+                                       &options);
+        selftest(np && !strcmp("testaliasoption", options),
+                 "option alias path test failed\n");
+        of_node_put(np);
+
+        np = of_find_node_opts_by_path("testcase-alias:testaliasoption", NULL);
+        selftest(np, "NULL option alias path test failed\n");
+        of_node_put(np);
+
+        options = "testoption";
+        np = of_find_node_opts_by_path("testcase-alias", &options);
+        selftest(np && !options, "option clearing test failed\n");
+        of_node_put(np);
+
+        options = "testoption";
+        np = of_find_node_opts_by_path("/", &options);
+        selftest(np && !options, "option clearing root node test failed\n");
+        of_node_put(np);
 }
 
 static void __init of_selftest_dynamic(void)
@@ -148,7 +182,7 @@ static void __init of_selftest_dynamic(void)
 
 static int __init of_selftest_check_node_linkage(struct device_node *np)
 {
-        struct device_node *child, *allnext_index = np;
+        struct device_node *child;
         int count = 0, rc;
 
         for_each_child_of_node(np, child) {
@@ -158,14 +192,6 @@ static int __init of_selftest_check_node_linkage(struct device_node *np)
                         return -EINVAL;
                 }
 
-                while (allnext_index && allnext_index != child)
-                        allnext_index = allnext_index->allnext;
-                if (allnext_index != child) {
-                        pr_err("Node %s is ordered differently in sibling and allnode lists\n",
-                                 child->name);
-                        return -EINVAL;
-                }
-
                 rc = of_selftest_check_node_linkage(child);
                 if (rc < 0)
                         return rc;
@@ -180,12 +206,12 @@ static void __init of_selftest_check_tree_linkage(void)
         struct device_node *np;
         int allnode_count = 0, child_count;
 
-        if (!of_allnodes)
+        if (!of_root)
                 return;
 
         for_each_of_allnodes(np)
                 allnode_count++;
-        child_count = of_selftest_check_node_linkage(of_allnodes);
+        child_count = of_selftest_check_node_linkage(of_root);
 
         selftest(child_count > 0, "Device node data structure is corrupted\n");
         selftest(child_count == allnode_count, "allnodes list size (%i) doesn't match"
@@ -451,15 +477,15 @@ static void __init of_selftest_changeset(void)
         struct property *ppadd, padd = { .name = "prop-add", .length = 0, .value = "" };
         struct property *ppupdate, pupdate = { .name = "prop-update", .length = 5, .value = "abcd" };
         struct property *ppremove;
-        struct device_node *n1, *n2, *n21, *nremove, *parent;
+        struct device_node *n1, *n2, *n21, *nremove, *parent, *np;
         struct of_changeset chgset;
 
         of_changeset_init(&chgset);
-        n1 = __of_node_alloc("/testcase-data/changeset/n1", GFP_KERNEL);
+        n1 = __of_node_dup(NULL, "/testcase-data/changeset/n1");
         selftest(n1, "testcase setup failure\n");
-        n2 = __of_node_alloc("/testcase-data/changeset/n2", GFP_KERNEL);
+        n2 = __of_node_dup(NULL, "/testcase-data/changeset/n2");
         selftest(n2, "testcase setup failure\n");
-        n21 = __of_node_alloc("/testcase-data/changeset/n2/n21", GFP_KERNEL);
+        n21 = __of_node_dup(NULL, "%s/%s", "/testcase-data/changeset/n2", "n21");
         selftest(n21, "testcase setup failure %p\n", n21);
         nremove = of_find_node_by_path("/testcase-data/changeset/node-remove");
         selftest(nremove, "testcase setup failure\n");
@@ -487,6 +513,11 @@ static void __init of_selftest_changeset(void)
         selftest(!of_changeset_apply(&chgset), "apply failed\n");
         mutex_unlock(&of_mutex);
 
+        /* Make sure node names are constructed correctly */
+        selftest((np = of_find_node_by_path("/testcase-data/changeset/n2/n21")),
+                 "'%s' not added\n", n21->full_name);
+        of_node_put(np);
+
         mutex_lock(&of_mutex);
         selftest(!of_changeset_revert(&chgset), "revert failed\n");
         mutex_unlock(&of_mutex);
@@ -702,10 +733,13 @@ static void __init of_selftest_match_node(void)
         }
 }
 
+struct device test_bus = {
+        .init_name = "unittest-bus",
+};
 static void __init of_selftest_platform_populate(void)
 {
-        int irq;
-        struct device_node *np, *child;
+        int irq, rc;
+        struct device_node *np, *child, *grandchild;
         struct platform_device *pdev;
         struct of_device_id match[] = {
                 { .compatible = "test-device", },
@@ -730,20 +764,32 @@ static void __init of_selftest_platform_populate(void)
         irq = platform_get_irq(pdev, 0);
         selftest(irq < 0 && irq != -EPROBE_DEFER, "device parsing error failed - %d\n", irq);
 
-        np = of_find_node_by_path("/testcase-data/platform-tests");
-        if (!np) {
-                pr_err("No testcase data in device tree\n");
+        if (selftest(np = of_find_node_by_path("/testcase-data/platform-tests"),
+                     "No testcase data in device tree\n"));
+                return;
+
+        if (selftest(!(rc = device_register(&test_bus)),
+                     "testbus registration failed; rc=%i\n", rc));
                 return;
-        }
 
         for_each_child_of_node(np, child) {
-                struct device_node *grandchild;
-                of_platform_populate(child, match, NULL, NULL);
+                of_platform_populate(child, match, NULL, &test_bus);
                 for_each_child_of_node(child, grandchild)
                         selftest(of_find_device_by_node(grandchild),
                                  "Could not create device for node '%s'\n",
                                  grandchild->name);
         }
+
+        of_platform_depopulate(&test_bus);
+        for_each_child_of_node(np, child) {
+                for_each_child_of_node(child, grandchild)
+                        selftest(!of_find_device_by_node(grandchild),
+                                 "device didn't get destroyed '%s'\n",
+                                 grandchild->name);
+        }
+
+        device_unregister(&test_bus);
+        of_node_put(np);
 }
 
 /**
@@ -775,33 +821,29 @@ static void update_node_properties(struct device_node *np,
  */
 static int attach_node_and_children(struct device_node *np)
 {
-        struct device_node *next, *root = np, *dup;
+        struct device_node *next, *dup, *child;
 
-        /* skip root node */
-        np = np->child;
-        /* storing a copy in temporary node */
-        dup = np;
+        dup = of_find_node_by_path(np->full_name);
+        if (dup) {
+                update_node_properties(np, dup);
+                return 0;
+        }
 
-        while (dup) {
+        /* Children of the root need to be remembered for removal */
+        if (np->parent == of_root) {
                 if (WARN_ON(last_node_index >= NO_OF_NODES))
                         return -EINVAL;
-                nodes[last_node_index++] = dup;
-                dup = dup->sibling;
+                nodes[last_node_index++] = np;
         }
-        dup = NULL;
 
-        while (np) {
-                next = np->allnext;
-                dup = of_find_node_by_path(np->full_name);
-                if (dup)
-                        update_node_properties(np, dup);
-                else {
-                        np->child = NULL;
-                        if (np->parent == root)
-                                np->parent = of_allnodes;
-                        of_attach_node(np);
-                }
-                np = next;
+        child = np->child;
+        np->child = NULL;
+        np->sibling = NULL;
+        of_attach_node(np);
+        while (child) {
+                next = child->sibling;
+                attach_node_and_children(child);
+                child = next;
         }
 
         return 0;
@@ -846,10 +888,10 @@ static int __init selftest_data_add(void)
                 return -EINVAL;
         }
 
-        if (!of_allnodes) {
+        if (!of_root) {
                 /* enabling flag for removing nodes */
                 selftest_live_tree = true;
-                of_allnodes = selftest_data_node;
+                of_root = selftest_data_node;
 
                 for_each_of_allnodes(np)
                         __of_attach_node_sysfs(np);
@@ -859,7 +901,14 @@ static int __init selftest_data_add(void)
         }
 
         /* attach the sub-tree to live tree */
-        return attach_node_and_children(selftest_data_node);
+        np = selftest_data_node->child;
+        while (np) {
+                struct device_node *next = np->sibling;
+                np->parent = of_root;
+                attach_node_and_children(np);
+                np = next;
+        }
+        return 0;
 }
 
 /**
@@ -889,10 +938,10 @@ static void selftest_data_remove(void)
                 of_node_put(of_chosen);
                 of_aliases = NULL;
                 of_chosen = NULL;
-                for_each_child_of_node(of_allnodes, np)
+                for_each_child_of_node(of_root, np)
                         detach_node_and_children(np);
-                __of_detach_node_sysfs(of_allnodes);
-                of_allnodes = NULL;
+                __of_detach_node_sysfs(of_root);
+                of_root = NULL;
                 return;
         }
 
@@ -915,6 +964,483 @@ static void selftest_data_remove(void)
         }
 }
 
+#ifdef CONFIG_OF_OVERLAY
+
+static int selftest_probe(struct platform_device *pdev)
+{
+        struct device *dev = &pdev->dev;
+        struct device_node *np = dev->of_node;
+
+        if (np == NULL) {
+                dev_err(dev, "No OF data for device\n");
+                return -EINVAL;
+
+        }
+
+        dev_dbg(dev, "%s for node @%s\n", __func__, np->full_name);
+        return 0;
+}
+
+static int selftest_remove(struct platform_device *pdev)
+{
+        struct device *dev = &pdev->dev;
+        struct device_node *np = dev->of_node;
+
+        dev_dbg(dev, "%s for node @%s\n", __func__, np->full_name);
+        return 0;
+}
+
+static struct of_device_id selftest_match[] = {
+        { .compatible = "selftest", },
+        {},
+};
+
+static struct platform_driver selftest_driver = {
+        .probe                  = selftest_probe,
+        .remove                 = selftest_remove,
+        .driver = {
+                .name           = "selftest",
+                .owner          = THIS_MODULE,
+                .of_match_table = of_match_ptr(selftest_match),
+        },
+};
+
+/* get the platform device instantiated at the path */
+static struct platform_device *of_path_to_platform_device(const char *path)
+{
+        struct device_node *np;
+        struct platform_device *pdev;
+
+        np = of_find_node_by_path(path);
+        if (np == NULL)
+                return NULL;
+
+        pdev = of_find_device_by_node(np);
+        of_node_put(np);
+
+        return pdev;
+}
+
+/* find out if a platform device exists at that path */
+static int of_path_platform_device_exists(const char *path)
+{
+        struct platform_device *pdev;
+
+        pdev = of_path_to_platform_device(path);
+        platform_device_put(pdev);
+        return pdev != NULL;
+}
+
+static const char *selftest_path(int nr)
+{
+        static char buf[256];
+
+        snprintf(buf, sizeof(buf) - 1,
+                "/testcase-data/overlay-node/test-bus/test-selftest%d", nr);
+        buf[sizeof(buf) - 1] = '\0';
+
+        return buf;
+}
+
+static const char *overlay_path(int nr)
+{
+        static char buf[256];
+
+        snprintf(buf, sizeof(buf) - 1,
+                "/testcase-data/overlay%d", nr);
+        buf[sizeof(buf) - 1] = '\0';
+
+        return buf;
+}
+
+static const char *bus_path = "/testcase-data/overlay-node/test-bus";
+
+static int of_selftest_apply_overlay(int selftest_nr, int overlay_nr,
+                int *overlay_id)
+{
+        struct device_node *np = NULL;
+        int ret, id = -1;
+
+        np = of_find_node_by_path(overlay_path(overlay_nr));
+        if (np == NULL) {
+                selftest(0, "could not find overlay node @\"%s\"\n",
+                                overlay_path(overlay_nr));
+                ret = -EINVAL;
+                goto out;
+        }
+
+        ret = of_overlay_create(np);
+        if (ret < 0) {
+                selftest(0, "could not create overlay from \"%s\"\n",
+                                overlay_path(overlay_nr));
+                goto out;
+        }
+        id = ret;
+
+        ret = 0;
+
+out:
+        of_node_put(np);
+
+        if (overlay_id)
+                *overlay_id = id;
+
+        return ret;
+}
+
+/* apply an overlay while checking before and after states */
+static int of_selftest_apply_overlay_check(int overlay_nr, int selftest_nr,
+                int before, int after)
+{
+        int ret;
+
+        /* selftest device must not be in before state */
+        if (of_path_platform_device_exists(selftest_path(selftest_nr))
+                        != before) {
+                selftest(0, "overlay @\"%s\" with device @\"%s\" %s\n",
+                                overlay_path(overlay_nr),
+                                selftest_path(selftest_nr),
+                                !before ? "enabled" : "disabled");
+                return -EINVAL;
+        }
+
+        ret = of_selftest_apply_overlay(overlay_nr, selftest_nr, NULL);
+        if (ret != 0) {
+                /* of_selftest_apply_overlay already called selftest() */
+                return ret;
+        }
+
+        /* selftest device must be to set to after state */
+        if (of_path_platform_device_exists(selftest_path(selftest_nr))
+                        != after) {
+                selftest(0, "overlay @\"%s\" failed to create @\"%s\" %s\n",
+                                overlay_path(overlay_nr),
+                                selftest_path(selftest_nr),
+                                !after ? "enabled" : "disabled");
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+/* apply an overlay and then revert it while checking before, after states */
+static int of_selftest_apply_revert_overlay_check(int overlay_nr,
+                int selftest_nr, int before, int after)
+{
+        int ret, ov_id;
+
+        /* selftest device must be in before state */
+        if (of_path_platform_device_exists(selftest_path(selftest_nr))
+                        != before) {
+                selftest(0, "overlay @\"%s\" with device @\"%s\" %s\n",
+                                overlay_path(overlay_nr),
+                                selftest_path(selftest_nr),
+                                !before ? "enabled" : "disabled");
+                return -EINVAL;
+        }
+
+        /* apply the overlay */
+        ret = of_selftest_apply_overlay(overlay_nr, selftest_nr, &ov_id);
+        if (ret != 0) {
+                /* of_selftest_apply_overlay already called selftest() */
+                return ret;
+        }
+
+        /* selftest device must be in after state */
+        if (of_path_platform_device_exists(selftest_path(selftest_nr))
+                        != after) {
+                selftest(0, "overlay @\"%s\" failed to create @\"%s\" %s\n",
+                                overlay_path(overlay_nr),
+                                selftest_path(selftest_nr),
+                                !after ? "enabled" : "disabled");
+                return -EINVAL;
+        }
+
+        ret = of_overlay_destroy(ov_id);
+        if (ret != 0) {
+                selftest(0, "overlay @\"%s\" failed to be destroyed @\"%s\"\n",
+                                overlay_path(overlay_nr),
+                                selftest_path(selftest_nr));
+                return ret;
+        }
+
+        /* selftest device must be again in before state */
+        if (of_path_platform_device_exists(selftest_path(selftest_nr))
+                        != before) {
+                selftest(0, "overlay @\"%s\" with device @\"%s\" %s\n",
+                                overlay_path(overlay_nr),
+                                selftest_path(selftest_nr),
+                                !before ? "enabled" : "disabled");
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+/* test activation of device */
+static void of_selftest_overlay_0(void)
+{
+        int ret;
+
+        /* device should enable */
+        ret = of_selftest_apply_overlay_check(0, 0, 0, 1);
+        if (ret != 0)
+                return;
+
+        selftest(1, "overlay test %d passed\n", 0);
+}
+
+/* test deactivation of device */
+static void of_selftest_overlay_1(void)
+{
+        int ret;
+
+        /* device should disable */
+        ret = of_selftest_apply_overlay_check(1, 1, 1, 0);
+        if (ret != 0)
+                return;
+
+        selftest(1, "overlay test %d passed\n", 1);
+}
+
+/* test activation of device */
+static void of_selftest_overlay_2(void)
+{
+        int ret;
+
+        /* device should enable */
+        ret = of_selftest_apply_overlay_check(2, 2, 0, 1);
+        if (ret != 0)
+                return;
+
+        selftest(1, "overlay test %d passed\n", 2);
+}
+
+/* test deactivation of device */
+static void of_selftest_overlay_3(void)
+{
+        int ret;
+
+        /* device should disable */
+        ret = of_selftest_apply_overlay_check(3, 3, 1, 0);
+        if (ret != 0)
+                return;
+
+        selftest(1, "overlay test %d passed\n", 3);
+}
+
+/* test activation of a full device node */
+static void of_selftest_overlay_4(void)
+{
+        int ret;
+
+        /* device should disable */
+        ret = of_selftest_apply_overlay_check(4, 4, 0, 1);
+        if (ret != 0)
+                return;
+
+        selftest(1, "overlay test %d passed\n", 4);
+}
+
+/* test overlay apply/revert sequence */
+static void of_selftest_overlay_5(void)
+{
+        int ret;
+
+        /* device should disable */
+        ret = of_selftest_apply_revert_overlay_check(5, 5, 0, 1);
+        if (ret != 0)
+                return;
+
+        selftest(1, "overlay test %d passed\n", 5);
+}
+
+/* test overlay application in sequence */
+static void of_selftest_overlay_6(void)
+{
+        struct device_node *np;
+        int ret, i, ov_id[2];
+        int overlay_nr = 6, selftest_nr = 6;
+        int before = 0, after = 1;
+
+        /* selftest device must be in before state */
+        for (i = 0; i < 2; i++) {
+                if (of_path_platform_device_exists(
+                                        selftest_path(selftest_nr + i))
+                                != before) {
+                        selftest(0, "overlay @\"%s\" with device @\"%s\" %s\n",
+                                        overlay_path(overlay_nr + i),
+                                        selftest_path(selftest_nr + i),
+                                        !before ? "enabled" : "disabled");
+                        return;
+                }
+        }
+
+        /* apply the overlays */
+        for (i = 0; i < 2; i++) {
+
+                np = of_find_node_by_path(overlay_path(overlay_nr + i));
+                if (np == NULL) {
+                        selftest(0, "could not find overlay node @\"%s\"\n",
+                                        overlay_path(overlay_nr + i));
+                        return;
+                }
+
+                ret = of_overlay_create(np);
+                if (ret < 0)  {
+                        selftest(0, "could not create overlay from \"%s\"\n",
+                                        overlay_path(overlay_nr + i));
+                        return;
+                }
+                ov_id[i] = ret;
+        }
+
+        for (i = 0; i < 2; i++) {
+                /* selftest device must be in after state */
+                if (of_path_platform_device_exists(
+                                        selftest_path(selftest_nr + i))
+                                != after) {
+                        selftest(0, "overlay @\"%s\" failed @\"%s\" %s\n",
+                                        overlay_path(overlay_nr + i),
+                                        selftest_path(selftest_nr + i),
+                                        !after ? "enabled" : "disabled");
+                        return;
+                }
+        }
+
+        for (i = 1; i >= 0; i--) {
+                ret = of_overlay_destroy(ov_id[i]);
+                if (ret != 0) {
+                        selftest(0, "overlay @\"%s\" failed destroy @\"%s\"\n",
+                                        overlay_path(overlay_nr + i),
+                                        selftest_path(selftest_nr + i));
+                        return;
+                }
+        }
+
+        for (i = 0; i < 2; i++) {
+                /* selftest device must be again in before state */
+                if (of_path_platform_device_exists(
+                                        selftest_path(selftest_nr + i))
+                                != before) {
+                        selftest(0, "overlay @\"%s\" with device @\"%s\" %s\n",
+                                        overlay_path(overlay_nr + i),
+                                        selftest_path(selftest_nr + i),
+                                        !before ? "enabled" : "disabled");
+                        return;
+                }
+        }
+
+        selftest(1, "overlay test %d passed\n", 6);
+}
+
+/* test overlay application in sequence */
+static void of_selftest_overlay_8(void)
+{
+        struct device_node *np;
+        int ret, i, ov_id[2];
+        int overlay_nr = 8, selftest_nr = 8;
+
+        /* we don't care about device state in this test */
+
+        /* apply the overlays */
+        for (i = 0; i < 2; i++) {
+
+                np = of_find_node_by_path(overlay_path(overlay_nr + i));
+                if (np == NULL) {
+                        selftest(0, "could not find overlay node @\"%s\"\n",
+                                        overlay_path(overlay_nr + i));
+                        return;
+                }
+
+                ret = of_overlay_create(np);
+                if (ret < 0)  {
+                        selftest(0, "could not create overlay from \"%s\"\n",
+                                        overlay_path(overlay_nr + i));
+                        return;
+                }
+                ov_id[i] = ret;
+        }
+
+        /* now try to remove first overlay (it should fail) */
+        ret = of_overlay_destroy(ov_id[0]);
+        if (ret == 0) {
+                selftest(0, "overlay @\"%s\" was destroyed @\"%s\"\n",
+                                overlay_path(overlay_nr + 0),
+                                selftest_path(selftest_nr));
+                return;
+        }
+
+        /* removing them in order should work */
+        for (i = 1; i >= 0; i--) {
+                ret = of_overlay_destroy(ov_id[i]);
+                if (ret != 0) {
+                        selftest(0, "overlay @\"%s\" not destroyed @\"%s\"\n",
+                                        overlay_path(overlay_nr + i),
+                                        selftest_path(selftest_nr));
+                        return;
+                }
+        }
+
+        selftest(1, "overlay test %d passed\n", 8);
+}
+
+static void __init of_selftest_overlay(void)
+{
+        struct device_node *bus_np = NULL;
+        int ret;
+
+        ret = platform_driver_register(&selftest_driver);
+        if (ret != 0) {
+                selftest(0, "could not register selftest driver\n");
+                goto out;
+        }
+
+        bus_np = of_find_node_by_path(bus_path);
+        if (bus_np == NULL) {
+                selftest(0, "could not find bus_path \"%s\"\n", bus_path);
+                goto out;
+        }
+
+        ret = of_platform_populate(bus_np, of_default_bus_match_table,
+                        NULL, NULL);
+        if (ret != 0) {
+                selftest(0, "could not populate bus @ \"%s\"\n", bus_path);
+                goto out;
+        }
+
+        if (!of_path_platform_device_exists(selftest_path(100))) {
+                selftest(0, "could not find selftest0 @ \"%s\"\n",
+                                selftest_path(100));
+                goto out;
+        }
+
+        if (of_path_platform_device_exists(selftest_path(101))) {
+                selftest(0, "selftest1 @ \"%s\" should not exist\n",
+                                selftest_path(101));
+                goto out;
+        }
+
+        selftest(1, "basic infrastructure of overlays passed");
+
+        /* tests in sequence */
+        of_selftest_overlay_0();
+        of_selftest_overlay_1();
+        of_selftest_overlay_2();
+        of_selftest_overlay_3();
+        of_selftest_overlay_4();
+        of_selftest_overlay_5();
+        of_selftest_overlay_6();
+        of_selftest_overlay_8();
+
+out:
+        of_node_put(bus_np);
+}
+
+#else
+static inline void __init of_selftest_overlay(void) { }
+#endif
+
 static int __init of_selftest(void)
 {
         struct device_node *np;
@@ -947,6 +1473,7 @@ static int __init of_selftest(void)
         of_selftest_parse_interrupts_extended();
         of_selftest_match_node();
         of_selftest_platform_populate();
+        of_selftest_overlay();
 
         /* removing selftest data from live tree */
         selftest_data_remove();
diff --git a/drivers/spi/spi.c b/drivers/spi/spi.c
index da7e6225b8f6..66a70e9bc743 100644
--- a/drivers/spi/spi.c
+++ b/drivers/spi/spi.c
@@ -1220,6 +1220,121 @@ err_init_queue:
 /*-------------------------------------------------------------------------*/
 
 #if defined(CONFIG_OF)
+static struct spi_device *
+of_register_spi_device(struct spi_master *master, struct device_node *nc)
+{
+        struct spi_device *spi;
+        int rc;
+        u32 value;
+
+        /* Alloc an spi_device */
+        spi = spi_alloc_device(master);
+        if (!spi) {
+                dev_err(&master->dev, "spi_device alloc error for %s\n",
+                        nc->full_name);
+                rc = -ENOMEM;
+                goto err_out;
+        }
+
+        /* Select device driver */
+        rc = of_modalias_node(nc, spi->modalias,
+                                sizeof(spi->modalias));
+        if (rc < 0) {
+                dev_err(&master->dev, "cannot find modalias for %s\n",
+                        nc->full_name);
+                goto err_out;
+        }
+
+        /* Device address */
+        rc = of_property_read_u32(nc, "reg", &value);
+        if (rc) {
+                dev_err(&master->dev, "%s has no valid 'reg' property (%d)\n",
+                        nc->full_name, rc);
+                goto err_out;
+        }
+        spi->chip_select = value;
+
+        /* Mode (clock phase/polarity/etc.) */
+        if (of_find_property(nc, "spi-cpha", NULL))
+                spi->mode |= SPI_CPHA;
+        if (of_find_property(nc, "spi-cpol", NULL))
+                spi->mode |= SPI_CPOL;
+        if (of_find_property(nc, "spi-cs-high", NULL))
+                spi->mode |= SPI_CS_HIGH;
+        if (of_find_property(nc, "spi-3wire", NULL))
+                spi->mode |= SPI_3WIRE;
+        if (of_find_property(nc, "spi-lsb-first", NULL))
+                spi->mode |= SPI_LSB_FIRST;
+
+        /* Device DUAL/QUAD mode */
+        if (!of_property_read_u32(nc, "spi-tx-bus-width", &value)) {
+                switch (value) {
+                case 1:
+                        break;
+                case 2:
+                        spi->mode |= SPI_TX_DUAL;
+                        break;
+                case 4:
+                        spi->mode |= SPI_TX_QUAD;
+                        break;
+                default:
+                        dev_warn(&master->dev,
+                                "spi-tx-bus-width %d not supported\n",
+                                value);
+                        break;
+                }
+        }
+
+        if (!of_property_read_u32(nc, "spi-rx-bus-width", &value)) {
+                switch (value) {
+                case 1:
+                        break;
+                case 2:
+                        spi->mode |= SPI_RX_DUAL;
+                        break;
+                case 4:
+                        spi->mode |= SPI_RX_QUAD;
+                        break;
+                default:
+                        dev_warn(&master->dev,
+                                "spi-rx-bus-width %d not supported\n",
+                                value);
+                        break;
+                }
+        }
+
+        /* Device speed */
+        rc = of_property_read_u32(nc, "spi-max-frequency", &value);
+        if (rc) {
+                dev_err(&master->dev, "%s has no valid 'spi-max-frequency' property (%d)\n",
+                        nc->full_name, rc);
+                goto err_out;
+        }
+        spi->max_speed_hz = value;
+
+        /* IRQ */
+        spi->irq = irq_of_parse_and_map(nc, 0);
+
+        /* Store a pointer to the node in the device structure */
+        of_node_get(nc);
+        spi->dev.of_node = nc;
+
+        /* Register the new device */
+        request_module("%s%s", SPI_MODULE_PREFIX, spi->modalias);
+        rc = spi_add_device(spi);
+        if (rc) {
+                dev_err(&master->dev, "spi_device register error %s\n",
+                        nc->full_name);
+                goto err_out;
+        }
+
+        return spi;
+
+err_out:
+        spi_dev_put(spi);
+        return ERR_PTR(rc);
+}
+
 /**
  * of_register_spi_devices() - Register child devices onto the SPI bus
  * @master:     Pointer to spi_master device
@@ -1231,116 +1346,15 @@ static void of_register_spi_devices(struct spi_master *master)
 {
         struct spi_device *spi;
         struct device_node *nc;
-        int rc;
-        u32 value;
 
         if (!master->dev.of_node)
                 return;
 
         for_each_available_child_of_node(master->dev.of_node, nc) {
-                /* Alloc an spi_device */
-                spi = spi_alloc_device(master);
-                if (!spi) {
-                        dev_err(&master->dev, "spi_device alloc error for %s\n",
+                spi = of_register_spi_device(master, nc);
+                if (IS_ERR(spi))
+                        dev_warn(&master->dev, "Failed to create SPI device for %s\n",
                                 nc->full_name);
-                        spi_dev_put(spi);
-                        continue;
-                }
-
-                /* Select device driver */
-                if (of_modalias_node(nc, spi->modalias,
-                                     sizeof(spi->modalias)) < 0) {
-                        dev_err(&master->dev, "cannot find modalias for %s\n",
-                                nc->full_name);
-                        spi_dev_put(spi);
-                        continue;
-                }
-
-                /* Device address */
-                rc = of_property_read_u32(nc, "reg", &value);
-                if (rc) {
-                        dev_err(&master->dev, "%s has no valid 'reg' property (%d)\n",
-                                nc->full_name, rc);
-                        spi_dev_put(spi);
-                        continue;
-                }
-                spi->chip_select = value;
-
-                /* Mode (clock phase/polarity/etc.) */
-                if (of_find_property(nc, "spi-cpha", NULL))
-                        spi->mode |= SPI_CPHA;
-                if (of_find_property(nc, "spi-cpol", NULL))
-                        spi->mode |= SPI_CPOL;
-                if (of_find_property(nc, "spi-cs-high", NULL))
-                        spi->mode |= SPI_CS_HIGH;
-                if (of_find_property(nc, "spi-3wire", NULL))
-                        spi->mode |= SPI_3WIRE;
-                if (of_find_property(nc, "spi-lsb-first", NULL))
-                        spi->mode |= SPI_LSB_FIRST;
-
-                /* Device DUAL/QUAD mode */
-                if (!of_property_read_u32(nc, "spi-tx-bus-width", &value)) {
-                        switch (value) {
-                        case 1:
-                                break;
-                        case 2:
-                                spi->mode |= SPI_TX_DUAL;
-                                break;
-                        case 4:
-                                spi->mode |= SPI_TX_QUAD;
-                                break;
-                        default:
-                                dev_warn(&master->dev,
-                                         "spi-tx-bus-width %d not supported\n",
-                                         value);
-                                break;
-                        }
-                }
-
-                if (!of_property_read_u32(nc, "spi-rx-bus-width", &value)) {
-                        switch (value) {
-                        case 1:
-                                break;
-                        case 2:
-                                spi->mode |= SPI_RX_DUAL;
-                                break;
-                        case 4:
-                                spi->mode |= SPI_RX_QUAD;
-                                break;
-                        default:
-                                dev_warn(&master->dev,
-                                         "spi-rx-bus-width %d not supported\n",
-                                         value);
-                                break;
-                        }
-                }
-
-                /* Device speed */
-                rc = of_property_read_u32(nc, "spi-max-frequency", &value);
-                if (rc) {
-                        dev_err(&master->dev, "%s has no valid 'spi-max-frequency' property (%d)\n",
-                                nc->full_name, rc);
-                        spi_dev_put(spi);
-                        continue;
-                }
-                spi->max_speed_hz = value;
-
-                /* IRQ */
-                spi->irq = irq_of_parse_and_map(nc, 0);
-
-                /* Store a pointer to the node in the device structure */
-                of_node_get(nc);
-                spi->dev.of_node = nc;
-
-                /* Register the new device */
-                request_module("%s%s", SPI_MODULE_PREFIX, spi->modalias);
-                rc = spi_add_device(spi);
-                if (rc) {
-                        dev_err(&master->dev, "spi_device register error %s\n",
-                                nc->full_name);
-                        spi_dev_put(spi);
-                }
-
         }
 }
 #else
@@ -2303,6 +2317,86 @@ EXPORT_SYMBOL_GPL(spi_write_then_read);
 
 /*-------------------------------------------------------------------------*/
 
+#if IS_ENABLED(CONFIG_OF_DYNAMIC)
+static int __spi_of_device_match(struct device *dev, void *data)
+{
+        return dev->of_node == data;
+}
+
+/* must call put_device() when done with returned spi_device device */
+static struct spi_device *of_find_spi_device_by_node(struct device_node *node)
+{
+        struct device *dev = bus_find_device(&spi_bus_type, NULL, node,
+                                                __spi_of_device_match);
+        return dev ? to_spi_device(dev) : NULL;
+}
+
+static int __spi_of_master_match(struct device *dev, const void *data)
+{
+        return dev->of_node == data;
+}
+
+/* the spi masters are not using spi_bus, so we find it with another way */
+static struct spi_master *of_find_spi_master_by_node(struct device_node *node)
+{
+        struct device *dev;
+
+        dev = class_find_device(&spi_master_class, NULL, node,
+                                __spi_of_master_match);
+        if (!dev)
+                return NULL;
+
+        /* reference got in class_find_device */
+        return container_of(dev, struct spi_master, dev);
+}
+
+static int of_spi_notify(struct notifier_block *nb, unsigned long action,
+                         void *arg)
+{
+        struct of_reconfig_data *rd = arg;
+        struct spi_master *master;
+        struct spi_device *spi;
+
+        switch (of_reconfig_get_state_change(action, arg)) {
+        case OF_RECONFIG_CHANGE_ADD:
+                master = of_find_spi_master_by_node(rd->dn->parent);
+                if (master == NULL)
+                        return NOTIFY_OK;       /* not for us */
+
+                spi = of_register_spi_device(master, rd->dn);
+                put_device(&master->dev);
+
+                if (IS_ERR(spi)) {
+                        pr_err("%s: failed to create for '%s'\n",
+                                        __func__, rd->dn->full_name);
+                        return notifier_from_errno(PTR_ERR(spi));
+                }
+                break;
+
+        case OF_RECONFIG_CHANGE_REMOVE:
+                /* find our device by node */
+                spi = of_find_spi_device_by_node(rd->dn);
+                if (spi == NULL)
+                        return NOTIFY_OK;       /* no? not meant for us */
+
+                /* unregister takes one ref away */
+                spi_unregister_device(spi);
+
+                /* and put the reference of the find */
+                put_device(&spi->dev);
+                break;
+        }
+
+        return NOTIFY_OK;
+}
+
+static struct notifier_block spi_of_notifier = {
+        .notifier_call = of_spi_notify,
+};
+#else /* IS_ENABLED(CONFIG_OF_DYNAMIC) */
+extern struct notifier_block spi_of_notifier;
+#endif /* IS_ENABLED(CONFIG_OF_DYNAMIC) */
+
 static int __init spi_init(void)
 {
         int     status;
@@ -2320,6 +2414,10 @@ static int __init spi_init(void)
         status = class_register(&spi_master_class);
         if (status < 0)
                 goto err2;
+
+        if (IS_ENABLED(CONFIG_OF_DYNAMIC))
+                WARN_ON(of_reconfig_notifier_register(&spi_of_notifier));
+
         return 0;
 
 err2: