type = IRQ_TYPE_LEVEL_LOW;
                break;
        default:
-               pr_err("Error: (%s) Invalid irq trigger specification: %x\n",
-                      node->name,
+               pr_err("Error: (%pOFn) Invalid irq trigger specification: %x\n",
+                      node,
                       trigger);
                type = IRQ_TYPE_LEVEL_LOW;
                break;
 
        parent_irq = irq_of_parse_and_map(ciu_node, 0);
        if (!parent_irq) {
-               pr_err("ERROR: Couldn't acquire parent_irq for %s\n",
-                       ciu_node->name);
+               pr_err("ERROR: Couldn't acquire parent_irq for %pOFn\n",
+                       ciu_node);
                return -EINVAL;
        }
 
 
        addr = of_get_address(ciu_node, 0, NULL, NULL);
        if (!addr) {
-               pr_err("ERROR: Couldn't acquire reg(0) %s\n", ciu_node->name);
+               pr_err("ERROR: Couldn't acquire reg(0) %pOFn\n", ciu_node);
                return -EINVAL;
        }
        host_data->raw_reg = (u64)phys_to_virt(
 
        addr = of_get_address(ciu_node, 1, NULL, NULL);
        if (!addr) {
-               pr_err("ERROR: Couldn't acquire reg(1) %s\n", ciu_node->name);
+               pr_err("ERROR: Couldn't acquire reg(1) %pOFn\n", ciu_node);
                return -EINVAL;
        }
        host_data->en_reg = (u64)phys_to_virt(
 
        r = of_property_read_u32(ciu_node, "cavium,max-bits", &val);
        if (r) {
-               pr_err("ERROR: Couldn't read cavium,max-bits from %s\n",
-                       ciu_node->name);
+               pr_err("ERROR: Couldn't read cavium,max-bits from %pOFn\n",
+                       ciu_node);
                return r;
        }
        host_data->max_bits = val;
 
        /* we need a hack to get the PIC's SoC chip id */
        ret = of_address_to_resource(node, 0, &res);
        if (ret < 0) {
-               pr_err("PIC %s: reg property not found!\n", node->name);
+               pr_err("PIC %pOFn: reg property not found!\n", node);
                return -EINVAL;
        }
 
                                break;
                }
                if (socid == NLM_NR_NODES) {
-                       pr_err("PIC %s: Node mapping for bus %d not found!\n",
-                                       node->name, bus);
+                       pr_err("PIC %pOFn: Node mapping for bus %d not found!\n",
+                                       node, bus);
                        return -EINVAL;
                }
        } else {
                socid = (res.start >> 18) & 0x3;
                if (!nlm_node_present(socid)) {
-                       pr_err("PIC %s: node %d does not exist!\n",
-                                                       node->name, socid);
+                       pr_err("PIC %pOFn: node %d does not exist!\n",
+                                                       node, socid);
                        return -EINVAL;
                }
        }
 
        if (!nlm_node_present(socid)) {
-               pr_err("PIC %s: node %d does not exist!\n", node->name, socid);
+               pr_err("PIC %pOFn: node %d does not exist!\n", node, socid);
                return -EINVAL;
        }
 
                nlm_irq_to_xirq(socid, PIC_IRQ_BASE), PIC_IRQ_BASE,
                &xlp_pic_irq_domain_ops, NULL);
        if (xlp_pic_domain == NULL) {
-               pr_err("PIC %s: Creating legacy domain failed!\n", node->name);
+               pr_err("PIC %pOFn: Creating legacy domain failed!\n", node);
                return -EINVAL;
        }
        pr_info("Node %d: IRQ domain created for PIC@%pR\n", socid, &res);
 
        systick.dev.min_delta_ticks = 0x3;
        systick.dev.irq = irq_of_parse_and_map(np, 0);
        if (!systick.dev.irq) {
-               pr_err("%s: request_irq failed", np->name);
+               pr_err("%pOFn: request_irq failed", np);
                return -EINVAL;
        }
 
 
        clockevents_register_device(&systick.dev);
 
-       pr_info("%s: running - mult: %d, shift: %d\n",
-                       np->name, systick.dev.mult, systick.dev.shift);
+       pr_info("%pOFn: running - mult: %d, shift: %d\n",
+                       np, systick.dev.mult, systick.dev.shift);
 
        return 0;
 }
 
 
        pdev = of_find_device_by_node(np);
        if (!pdev) {
-               pr_err("%s: failed to lookup pdev\n", np->name);
+               pr_err("%pOFn: failed to lookup pdev\n", np);
                return -EINVAL;
        }