struct platform_device *ofdev;
 
        ofdev = to_platform_device(dev);
-       return sprintf(buf, "%s\n", ofdev->dev.of_node->full_name);
+       return sprintf(buf, "%pOF\n", ofdev->dev.of_node);
 }
 static DEVICE_ATTR_RO(modalias);
 static DEVICE_ATTR_RO(devspec);
 
 #if 0 /* Use that when i2s-a is finally an mdev per-se */
        if (macio_resource_count(mdev) < 2 || macio_irq_count(mdev) < 2) {
                printk(KERN_ERR
-                      "rackmeter: found match but lacks resources: %s"
+                      "rackmeter: found match but lacks resources: %pOF"
                       " (%d resources, %d interrupts)\n",
-                      mdev->ofdev.node->full_name);
+                      mdev->ofdev.dev.of_node);
                rc = -ENXIO;
                goto bail_free;
        }
        if (macio_request_resources(mdev, "rackmeter")) {
                printk(KERN_ERR
-                      "rackmeter: failed to request resources: %s\n",
-                      mdev->ofdev.node->full_name);
+                      "rackmeter: failed to request resources: %pOF\n",
+                      mdev->ofdev.dev.of_node);
                rc = -EBUSY;
                goto bail_free;
        }
            of_address_to_resource(i2s, 0, &ri2s) ||
            of_address_to_resource(i2s, 1, &rdma)) {
                printk(KERN_ERR
-                      "rackmeter: found match but lacks resources: %s",
-                      mdev->ofdev.dev.of_node->full_name);
+                      "rackmeter: found match but lacks resources: %pOF",
+                      mdev->ofdev.dev.of_node);
                rc = -ENXIO;
                goto bail_free;
        }
 
        if (smu->db_node) {
                smu->db_irq = irq_of_parse_and_map(smu->db_node, 0);
                if (!smu->db_irq)
-                       printk(KERN_ERR "smu: failed to map irq for node %s\n",
-                              smu->db_node->full_name);
+                       printk(KERN_ERR "smu: failed to map irq for node %pOF\n",
+                              smu->db_node);
        }
        if (smu->msg_node) {
                smu->msg_irq = irq_of_parse_and_map(smu->msg_node, 0);
                if (!smu->msg_irq)
-                       printk(KERN_ERR "smu: failed to map irq for node %s\n",
-                              smu->msg_node->full_name);
+                       printk(KERN_ERR "smu: failed to map irq for node %pOF\n",
+                              smu->msg_node);
        }
 
        /*
 
 #else
     cuda_irq = irq_of_parse_and_map(vias, 0);
     if (!cuda_irq) {
-       printk(KERN_ERR "via-cuda: can't map interrupts for %s\n",
-              vias->full_name);
+       printk(KERN_ERR "via-cuda: can't map interrupts for %pOF\n",
+              vias);
        return -ENODEV;
     }
 #endif
 
                                id = ((*reg) - 0x30) / 2;
                        if (id > 7) {
                                pr_warning("wf_fcu: Can't parse "
-                                      "fan ID in device-tree for %s\n",
-                                          np->full_name);
+                                      "fan ID in device-tree for %pOF\n",
+                                          np);
                                break;
                        }
                        wf_fcu_add_fan(pv, name, type, id);
 
                }
        }
        if (!name) {
-               pr_warning("wf_lm87: Unsupported sensor %s\n",
-                          client->dev.of_node->full_name);
+               pr_warning("wf_lm87: Unsupported sensor %pOF\n",
+                          client->dev.of_node);
                return -ENODEV;
        }
 
 
                core = loc[5] - '0';
                if (chip > 1 || core > 1) {
                        printk(KERN_ERR "wf_sat_create: don't understand "
-                              "location %s for %s\n", loc, child->full_name);
+                              "location %s for %pOF\n", loc, child);
                        continue;
                }
                cpu = 2 * chip + core;