if (!name)
                        return -EINVAL;
                ret = device_bind_driver_to_node(dev, drv_name, name,
-                                                offset, NULL);
+                                       offset_to_ofnode(offset), NULL);
                if (ret)
                        return ret;
        }
 
 int device_bind_driver(struct udevice *parent, const char *drv_name,
                       const char *dev_name, struct udevice **devp)
 {
-       return device_bind_driver_to_node(parent, drv_name, dev_name, -1, devp);
+       return device_bind_driver_to_node(parent, drv_name, dev_name,
+                                         ofnode_null(), devp);
 }
 
 int device_bind_driver_to_node(struct udevice *parent, const char *drv_name,
-                              const char *dev_name, int node,
+                              const char *dev_name, ofnode node,
                               struct udevice **devp)
 {
        struct driver *drv;
                debug("Cannot find driver '%s'\n", drv_name);
                return -ENOENT;
        }
-       ret = device_bind(parent, drv, dev_name, NULL, node, devp);
-       if (ret) {
-               debug("Cannot create device named '%s' (err=%d)\n",
-                     dev_name, ret);
-               return ret;
-       }
+       ret = device_bind_with_driver_data(parent, drv, dev_name, 0 /* data */,
+                                          node, devp);
 
-       return 0;
+       return ret;
 }
 
 #if CONFIG_IS_ENABLED(OF_CONTROL) && !CONFIG_IS_ENABLED(OF_PLATDATA)
 
 static int uclass_cpu_init(struct uclass *uc)
 {
        struct udevice *dev;
-       int node;
+       ofnode node;
        int ret;
 
-       node = fdt_path_offset(gd->fdt_blob, "/cpus");
-       if (node < 0)
+       node = ofnode_path("/cpus");
+       if (!ofnode_valid(node))
                return 0;
 
        ret = device_bind_driver_to_node(dm_root(), "cpu_bus", "cpus", node,
 
 /* Find the I2C buses selected by this mux */
 static int i2c_mux_post_bind(struct udevice *mux)
 {
-       const void *blob = gd->fdt_blob;
+       ofnode node;
        int ret;
-       int offset;
 
        debug("%s: %s\n", __func__, mux->name);
        /*
         * There is no compatible string in the sub-nodes, so we must manually
         * bind these
         */
-       for (offset = fdt_first_subnode(blob, dev_of_offset(mux));
-            offset > 0;
-            offset = fdt_next_subnode(blob, offset)) {
+       dev_for_each_subnode(node, mux) {
                struct udevice *dev;
                const char *name;
 
-               name = fdt_get_name(blob, offset, NULL);
+               name = ofnode_get_name(node);
                ret = device_bind_driver_to_node(mux, "i2c_mux_bus_drv", name,
-                                                offset, &dev);
+                                                node, &dev);
                debug("   - bind ret=%d, %s\n", ret, dev ? dev->name : NULL);
                if (ret)
                        return ret;
 
 
                ret = device_bind_driver_to_node(parent, "bcm6328-led",
                                                 fdt_get_name(blob, node, NULL),
-                                                node, &dev);
+                                                offset_to_ofnode(node), &dev);
                if (ret)
                        return ret;
 
 
 
                ret = device_bind_driver_to_node(parent, "bcm6358-led",
                                                 fdt_get_name(blob, node, NULL),
-                                                node, &dev);
+                                                offset_to_ofnode(node), &dev);
                if (ret)
                        return ret;
 
 
 
 static int led_gpio_bind(struct udevice *parent)
 {
-       const void *blob = gd->fdt_blob;
        struct udevice *dev;
-       int node;
+       ofnode node;
        int ret;
 
-       for (node = fdt_first_subnode(blob, dev_of_offset(parent));
-            node > 0;
-            node = fdt_next_subnode(blob, node)) {
+       dev_for_each_subnode(node, parent) {
                struct led_uc_plat *uc_plat;
                const char *label;
 
-               label = fdt_getprop(blob, node, "label", NULL);
+               label = ofnode_read_string(node, "label");
                if (!label) {
                        debug("%s: node %s has no label\n", __func__,
-                             fdt_get_name(blob, node, NULL));
+                             ofnode_get_name(node));
                        return -EINVAL;
                }
                ret = device_bind_driver_to_node(parent, "gpio_led",
-                                                fdt_get_name(blob, node, NULL),
+                                                ofnode_get_name(node),
                                                 node, &dev);
                if (ret)
                        return ret;
 
        debug("%s(dev=%p)\n", __func__, dev);
 
        ret = device_bind_driver_to_node(dev, "tegra186_clk", "tegra186_clk",
-                                        dev_of_offset(dev), &child);
+                                        dev_ofnode(dev), &child);
        if (ret)
                return ret;
 
        ret = device_bind_driver_to_node(dev, "tegra186_reset",
-                                        "tegra186_reset", dev_of_offset(dev),
+                                        "tegra186_reset", dev_ofnode(dev),
                                         &child);
        if (ret)
                return ret;
 
        ret = device_bind_driver_to_node(dev, "tegra186_power_domain",
                                         "tegra186_power_domain",
-                                        dev_of_offset(dev), &child);
+                                        dev_ofnode(dev), &child);
        if (ret)
                return ret;
 
 
        debug("%s(dev=%p)\n", __func__, dev);
 
        ret = device_bind_driver_to_node(dev, "tegra_car_clk", "tegra_car_clk",
-                                        dev_of_offset(dev), &child);
+                                        dev_ofnode(dev), &child);
        if (ret)
                return ret;
 
        ret = device_bind_driver_to_node(dev, "tegra_car_reset",
-                                        "tegra_car_reset", dev_of_offset(dev),
+                                        "tegra_car_reset", dev_ofnode(dev),
                                         &child);
        if (ret)
                return ret;
 
                        slave_name = malloc(20);
                        snprintf(slave_name, 20, "netcp@slave-%d", slave_no);
                        ret = device_bind_driver_to_node(dev, "eth_ks2_sl",
-                                                        slave_name, slave,
-                                                        &sl_dev);
+                                       slave_name, offset_to_ofnode(slave),
+                                       &sl_dev);
                        if (ret) {
                                error("ks2_net - not able to bind slave interfaces\n");
                                return ret;
                slave_name = malloc(20);
                snprintf(slave_name, 20, "netcp@slave-%d", slave_no);
                ret = device_bind_driver_to_node(dev, "eth_ks2_sl", slave_name,
-                                                slave, &sl_dev);
+                                       offset_to_ofnode(slave), &sl_dev);
                if (ret) {
                        error("ks2_net - not able to bind slave interfaces\n");
                        return ret;
 
  */
 static int pinconfig_post_bind(struct udevice *dev)
 {
-       const void *fdt = gd->fdt_blob;
-       int offset = dev_of_offset(dev);
        bool pre_reloc_only = !(gd->flags & GD_FLG_RELOC);
        const char *name;
+       ofnode node;
        int ret;
 
-       for (offset = fdt_first_subnode(fdt, offset);
-            offset > 0;
-            offset = fdt_next_subnode(fdt, offset)) {
+       dev_for_each_subnode(node, dev) {
                if (pre_reloc_only &&
-                   !dm_fdt_pre_reloc(fdt, offset))
+                   !ofnode_pre_reloc(node))
                        continue;
                /*
                 * If this node has "compatible" property, this is not
                 * a pin configuration node, but a normal device. skip.
                 */
-               fdt_get_property(fdt, offset, "compatible", &ret);
+               ofnode_read_prop(node, "compatible", &ret);
                if (ret >= 0)
                        continue;
 
                if (ret != -FDT_ERR_NOTFOUND)
                        return ret;
 
-               name = fdt_get_name(fdt, offset, NULL);
+               name = ofnode_get_name(node);
                if (!name)
                        return -EINVAL;
                ret = device_bind_driver_to_node(dev, "pinconfig", name,
-                                                offset, NULL);
+                                                node, NULL);
                if (ret)
                        return ret;
        }
 
                case USB_DR_MODE_HOST:
                        /* Bind MUSB host */
                        ret = device_bind_driver_to_node(parent, "ti-musb-host",
-                                                        name, node, &dev);
+                                       name, offset_to_ofnode(node), &dev);
                        if (ret) {
                                error("musb - not able to bind usb host node\n");
                                return ret;
 
 #include <dm/ofnode.h>
 #include <dm/device.h>
 #include <dm/fdtaddr.h>
+#include <dm/ofnode.h>
+#include <dm/read.h>
 #include <dm/platdata.h>
 #include <dm/uclass.h>
 
 
  * @devp:      If non-NULL, returns the newly bound device
  */
 int device_bind_driver_to_node(struct udevice *parent, const char *drv_name,
-                              const char *dev_name, int node,
+                              const char *dev_name, ofnode node,
                               struct udevice **devp);
 
 #endif