net: Convert to using %pOF instead of full_name
authorRob Herring <robh@kernel.org>
Tue, 18 Jul 2017 21:43:19 +0000 (16:43 -0500)
committerDavid S. Miller <davem@davemloft.net>
Mon, 24 Jul 2017 20:41:48 +0000 (13:41 -0700)
Now that we have a custom printf format specifier, convert users of
full_name to use %pOF instead. This is preparation to remove storing
of the full path string for each node.

Signed-off-by: Rob Herring <robh@kernel.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
21 files changed:
drivers/net/dsa/mv88e6xxx/chip.c
drivers/net/ethernet/apple/mace.c
drivers/net/ethernet/freescale/dpaa/dpaa_eth.c
drivers/net/ethernet/freescale/fec_mpc52xx.c
drivers/net/ethernet/freescale/fman/fman.c
drivers/net/ethernet/freescale/fman/fman_port.c
drivers/net/ethernet/freescale/fman/mac.c
drivers/net/ethernet/freescale/fsl_pq_mdio.c
drivers/net/ethernet/ibm/ehea/ehea_main.c
drivers/net/ethernet/ibm/emac/core.c
drivers/net/ethernet/ibm/emac/debug.h
drivers/net/ethernet/ibm/emac/mal.c
drivers/net/ethernet/ibm/emac/rgmii.c
drivers/net/ethernet/ibm/emac/tah.c
drivers/net/ethernet/ibm/emac/zmii.c
drivers/net/ethernet/sun/niu.c
drivers/net/ethernet/ti/cpsw.c
drivers/net/ethernet/ti/davinci_emac.c
drivers/net/ethernet/xilinx/ll_temac_main.c
drivers/net/phy/mdio-mux-mmioreg.c
drivers/net/phy/mdio-mux.c

index 7fa19d4a8e13271d8ebc0fb4d384b75a32c6aa10..647d5d45c1d6cdf4603248b7b560eb9434de561c 100644 (file)
@@ -2242,7 +2242,7 @@ static int mv88e6xxx_mdio_register(struct mv88e6xxx_chip *chip,
 
        if (np) {
                bus->name = np->full_name;
-               snprintf(bus->id, MII_BUS_ID_SIZE, "%s", np->full_name);
+               snprintf(bus->id, MII_BUS_ID_SIZE, "%pOF", np);
        } else {
                bus->name = "mv88e6xxx SMI";
                snprintf(bus->id, MII_BUS_ID_SIZE, "mv88e6xxx-%d", index++);
index 96dd5300e0e5f500844ba980099139e0487b5d20..e58b157b7d7c4238c5ea3f384575ce4b2ab3dac7 100644 (file)
@@ -114,8 +114,8 @@ static int mace_probe(struct macio_dev *mdev, const struct of_device_id *match)
        int j, rev, rc = -EBUSY;
 
        if (macio_resource_count(mdev) != 3 || macio_irq_count(mdev) != 3) {
-               printk(KERN_ERR "can't use MACE %s: need 3 addrs and 3 irqs\n",
-                      mace->full_name);
+               printk(KERN_ERR "can't use MACE %pOF: need 3 addrs and 3 irqs\n",
+                      mace);
                return -ENODEV;
        }
 
@@ -123,8 +123,8 @@ static int mace_probe(struct macio_dev *mdev, const struct of_device_id *match)
        if (addr == NULL) {
                addr = of_get_property(mace, "local-mac-address", NULL);
                if (addr == NULL) {
-                       printk(KERN_ERR "Can't get mac-address for MACE %s\n",
-                              mace->full_name);
+                       printk(KERN_ERR "Can't get mac-address for MACE %pOF\n",
+                              mace);
                        return -ENODEV;
                }
        }
index 757b873735a5efd5b720321568341ca591726bba..550ea1ec7b6c95e2fdbed57301c9935b4e33422b 100644 (file)
@@ -398,8 +398,8 @@ static struct mac_device *dpaa_mac_dev_get(struct platform_device *pdev)
 
        of_dev = of_find_device_by_node(mac_node);
        if (!of_dev) {
-               dev_err(dpaa_dev, "of_find_device_by_node(%s) failed\n",
-                       mac_node->full_name);
+               dev_err(dpaa_dev, "of_find_device_by_node(%pOF) failed\n",
+                       mac_node);
                of_node_put(mac_node);
                return ERR_PTR(-EINVAL);
        }
index aa8cf5d2a53cdf98523d94f5a0200cb5315dbe38..6d7269d87a850bb4da693b19d5598bc81d18788a 100644 (file)
@@ -960,8 +960,8 @@ static int mpc52xx_fec_probe(struct platform_device *op)
 
        /* We're done ! */
        platform_set_drvdata(op, ndev);
-       netdev_info(ndev, "%s MAC %pM\n",
-                   op->dev.of_node->full_name, ndev->dev_addr);
+       netdev_info(ndev, "%pOF MAC %pM\n",
+                   op->dev.of_node, ndev->dev_addr);
 
        return 0;
 
index 4aefe24389695457ee307a9eb3403715091d283c..e714b8fa55eb36119a2ef3c8e35b2c688e748466 100644 (file)
@@ -1925,8 +1925,8 @@ static int fman_reset(struct fman *fman)
 
                guts_regs = of_iomap(guts_node, 0);
                if (!guts_regs) {
-                       dev_err(fman->dev, "%s: Couldn't map %s regs\n",
-                               __func__, guts_node->full_name);
+                       dev_err(fman->dev, "%s: Couldn't map %pOF regs\n",
+                               __func__, guts_node);
                        goto guts_regs;
                }
 #define FMAN1_ALL_MACS_MASK    0xFCC00000
@@ -2780,8 +2780,8 @@ static struct fman *read_dts_node(struct platform_device *of_dev)
 
        err = of_property_read_u32(fm_node, "cell-index", &val);
        if (err) {
-               dev_err(&of_dev->dev, "%s: failed to read cell-index for %s\n",
-                       __func__, fm_node->full_name);
+               dev_err(&of_dev->dev, "%s: failed to read cell-index for %pOF\n",
+                       __func__, fm_node);
                goto fman_node_put;
        }
        fman->dts_params.id = (u8)val;
@@ -2834,8 +2834,8 @@ static struct fman *read_dts_node(struct platform_device *of_dev)
        err = of_property_read_u32_array(fm_node, "fsl,qman-channel-range",
                                         &range[0], 2);
        if (err) {
-               dev_err(&of_dev->dev, "%s: failed to read fsl,qman-channel-range for %s\n",
-                       __func__, fm_node->full_name);
+               dev_err(&of_dev->dev, "%s: failed to read fsl,qman-channel-range for %pOF\n",
+                       __func__, fm_node);
                goto fman_node_put;
        }
        fman->dts_params.qman_channel_base = range[0];
index 57bf44fa16a10ad54e1f56fa5cb5304d3039ed2c..49bfa11f2d20f16d0d859ccf8ebade810c5306ad 100644 (file)
@@ -1720,8 +1720,8 @@ static int fman_port_probe(struct platform_device *of_dev)
 
        err = of_property_read_u32(port_node, "cell-index", &val);
        if (err) {
-               dev_err(port->dev, "%s: reading cell-index for %s failed\n",
-                       __func__, port_node->full_name);
+               dev_err(port->dev, "%s: reading cell-index for %pOF failed\n",
+                       __func__, port_node);
                err = -EINVAL;
                goto return_err;
        }
index 6e67d22fd0d54f69e5ee3358717e7ed539fad952..14cd2c8b00248298088337c62a288f8c99039ec3 100644 (file)
@@ -698,8 +698,8 @@ static int mac_probe(struct platform_device *_of_dev)
                priv->internal_phy_node = of_parse_phandle(mac_node,
                                                          "pcsphy-handle", 0);
        } else {
-               dev_err(dev, "MAC node (%s) contains unsupported MAC\n",
-                       mac_node->full_name);
+               dev_err(dev, "MAC node (%pOF) contains unsupported MAC\n",
+                       mac_node);
                err = -EINVAL;
                goto _return;
        }
@@ -712,16 +712,15 @@ static int mac_probe(struct platform_device *_of_dev)
        /* Get the FM node */
        dev_node = of_get_parent(mac_node);
        if (!dev_node) {
-               dev_err(dev, "of_get_parent(%s) failed\n",
-                       mac_node->full_name);
+               dev_err(dev, "of_get_parent(%pOF) failed\n",
+                       mac_node);
                err = -EINVAL;
                goto _return_dev_set_drvdata;
        }
 
        of_dev = of_find_device_by_node(dev_node);
        if (!of_dev) {
-               dev_err(dev, "of_find_device_by_node(%s) failed\n",
-                       dev_node->full_name);
+               dev_err(dev, "of_find_device_by_node(%pOF) failed\n", dev_node);
                err = -EINVAL;
                goto _return_of_node_put;
        }
@@ -729,8 +728,7 @@ static int mac_probe(struct platform_device *_of_dev)
        /* Get the FMan cell-index */
        err = of_property_read_u32(dev_node, "cell-index", &val);
        if (err) {
-               dev_err(dev, "failed to read cell-index for %s\n",
-                       dev_node->full_name);
+               dev_err(dev, "failed to read cell-index for %pOF\n", dev_node);
                err = -EINVAL;
                goto _return_of_node_put;
        }
@@ -739,7 +737,7 @@ static int mac_probe(struct platform_device *_of_dev)
 
        priv->fman = fman_bind(&of_dev->dev);
        if (!priv->fman) {
-               dev_err(dev, "fman_bind(%s) failed\n", dev_node->full_name);
+               dev_err(dev, "fman_bind(%pOF) failed\n", dev_node);
                err = -ENODEV;
                goto _return_of_node_put;
        }
@@ -749,8 +747,8 @@ static int mac_probe(struct platform_device *_of_dev)
        /* Get the address of the memory mapped registers */
        err = of_address_to_resource(mac_node, 0, &res);
        if (err < 0) {
-               dev_err(dev, "of_address_to_resource(%s) = %d\n",
-                       mac_node->full_name, err);
+               dev_err(dev, "of_address_to_resource(%pOF) = %d\n",
+                       mac_node, err);
                goto _return_dev_set_drvdata;
        }
 
@@ -784,8 +782,7 @@ static int mac_probe(struct platform_device *_of_dev)
        /* Get the cell-index */
        err = of_property_read_u32(mac_node, "cell-index", &val);
        if (err) {
-               dev_err(dev, "failed to read cell-index for %s\n",
-                       mac_node->full_name);
+               dev_err(dev, "failed to read cell-index for %pOF\n", mac_node);
                err = -EINVAL;
                goto _return_dev_set_drvdata;
        }
@@ -794,8 +791,7 @@ static int mac_probe(struct platform_device *_of_dev)
        /* Get the MAC address */
        mac_addr = of_get_mac_address(mac_node);
        if (!mac_addr) {
-               dev_err(dev, "of_get_mac_address(%s) failed\n",
-                       mac_node->full_name);
+               dev_err(dev, "of_get_mac_address(%pOF) failed\n", mac_node);
                err = -EINVAL;
                goto _return_dev_set_drvdata;
        }
@@ -804,15 +800,15 @@ static int mac_probe(struct platform_device *_of_dev)
        /* Get the port handles */
        nph = of_count_phandle_with_args(mac_node, "fsl,fman-ports", NULL);
        if (unlikely(nph < 0)) {
-               dev_err(dev, "of_count_phandle_with_args(%s, fsl,fman-ports) failed\n",
-                       mac_node->full_name);
+               dev_err(dev, "of_count_phandle_with_args(%pOF, fsl,fman-ports) failed\n",
+                       mac_node);
                err = nph;
                goto _return_dev_set_drvdata;
        }
 
        if (nph != ARRAY_SIZE(mac_dev->port)) {
-               dev_err(dev, "Not supported number of fman-ports handles of mac node %s from device tree\n",
-                       mac_node->full_name);
+               dev_err(dev, "Not supported number of fman-ports handles of mac node %pOF from device tree\n",
+                       mac_node);
                err = -EINVAL;
                goto _return_dev_set_drvdata;
        }
@@ -821,24 +817,24 @@ static int mac_probe(struct platform_device *_of_dev)
                /* Find the port node */
                dev_node = of_parse_phandle(mac_node, "fsl,fman-ports", i);
                if (!dev_node) {
-                       dev_err(dev, "of_parse_phandle(%s, fsl,fman-ports) failed\n",
-                               mac_node->full_name);
+                       dev_err(dev, "of_parse_phandle(%pOF, fsl,fman-ports) failed\n",
+                               mac_node);
                        err = -EINVAL;
                        goto _return_of_node_put;
                }
 
                of_dev = of_find_device_by_node(dev_node);
                if (!of_dev) {
-                       dev_err(dev, "of_find_device_by_node(%s) failed\n",
-                               dev_node->full_name);
+                       dev_err(dev, "of_find_device_by_node(%pOF) failed\n",
+                               dev_node);
                        err = -EINVAL;
                        goto _return_of_node_put;
                }
 
                mac_dev->port[i] = fman_port_bind(&of_dev->dev);
                if (!mac_dev->port[i]) {
-                       dev_err(dev, "dev_get_drvdata(%s) failed\n",
-                               dev_node->full_name);
+                       dev_err(dev, "dev_get_drvdata(%pOF) failed\n",
+                               dev_node);
                        err = -EINVAL;
                        goto _return_of_node_put;
                }
@@ -849,8 +845,8 @@ static int mac_probe(struct platform_device *_of_dev)
        phy_if = of_get_phy_mode(mac_node);
        if (phy_if < 0) {
                dev_warn(dev,
-                        "of_get_phy_mode() for %s failed. Defaulting to SGMII\n",
-                        mac_node->full_name);
+                        "of_get_phy_mode() for %pOF failed. Defaulting to SGMII\n",
+                        mac_node);
                phy_if = PHY_INTERFACE_MODE_SGMII;
        }
        priv->phy_if = phy_if;
index a10de1e9c157d2590eb19122f27fd5dda1a4816b..80ad16acf0f13ac32e7b09b1b3df05b30df44341 100644 (file)
@@ -267,8 +267,8 @@ static void ucc_configure(phys_addr_t start, phys_addr_t end)
 
                ret = of_address_to_resource(np, 0, &res);
                if (ret < 0) {
-                       pr_debug("fsl-pq-mdio: no address range in node %s\n",
-                                np->full_name);
+                       pr_debug("fsl-pq-mdio: no address range in node %pOF\n",
+                                np);
                        continue;
                }
 
@@ -280,8 +280,8 @@ static void ucc_configure(phys_addr_t start, phys_addr_t end)
                if (!iprop) {
                        iprop = of_get_property(np, "device-id", NULL);
                        if (!iprop) {
-                               pr_debug("fsl-pq-mdio: no UCC ID in node %s\n",
-                                        np->full_name);
+                               pr_debug("fsl-pq-mdio: no UCC ID in node %pOF\n",
+                                        np);
                                continue;
                        }
                }
@@ -293,8 +293,8 @@ static void ucc_configure(phys_addr_t start, phys_addr_t end)
                 * numbered from 1, not 0.
                 */
                if (ucc_set_qe_mux_mii_mng(id - 1) < 0) {
-                       pr_debug("fsl-pq-mdio: invalid UCC ID in node %s\n",
-                                np->full_name);
+                       pr_debug("fsl-pq-mdio: invalid UCC ID in node %pOF\n",
+                                np);
                        continue;
                }
 
@@ -442,8 +442,8 @@ static int fsl_pq_mdio_probe(struct platform_device *pdev)
        if (data->get_tbipa) {
                for_each_child_of_node(np, tbi) {
                        if (strcmp(tbi->type, "tbi-phy") == 0) {
-                               dev_dbg(&pdev->dev, "found TBI PHY node %s\n",
-                                       strrchr(tbi->full_name, '/') + 1);
+                               dev_dbg(&pdev->dev, "found TBI PHY node %pOFP\n",
+                                       tbi);
                                break;
                        }
                }
@@ -454,8 +454,8 @@ static int fsl_pq_mdio_probe(struct platform_device *pdev)
 
                        if (!prop) {
                                dev_err(&pdev->dev,
-                                       "missing 'reg' property in node %s\n",
-                                       tbi->full_name);
+                                       "missing 'reg' property in node %pOF\n",
+                                       tbi);
                                err = -EBUSY;
                                goto error;
                        }
index b9d310f20bcc1c69ac3423e49bfa75f1e2a64fea..4878b7169e0f5835a72107a57eb9f8c4aecedf2e 100644 (file)
@@ -3102,8 +3102,7 @@ static int ehea_setup_ports(struct ehea_adapter *adapter)
                dn_log_port_id = of_get_property(eth_dn, "ibm,hea-port-no",
                                                 NULL);
                if (!dn_log_port_id) {
-                       pr_err("bad device node: eth_dn name=%s\n",
-                              eth_dn->full_name);
+                       pr_err("bad device node: eth_dn name=%pOF\n", eth_dn);
                        continue;
                }
 
@@ -3425,7 +3424,7 @@ static int ehea_probe_adapter(struct platform_device *dev)
 
        if (!adapter->handle) {
                dev_err(&dev->dev, "failed getting handle for adapter"
-                       " '%s'\n", dev->dev.of_node->full_name);
+                       " '%pOF'\n", dev->dev.of_node);
                ret = -ENODEV;
                goto out_free_ad;
        }
index 259e69a52ec52acde37849b9858c9953029679af..95135d20458fbd74926868ed42fe1430f3920128 100644 (file)
@@ -133,8 +133,7 @@ static inline void emac_report_timeout_error(struct emac_instance *dev,
                                  EMAC_FTR_440EP_PHY_CLK_FIX))
                DBG(dev, "%s" NL, error);
        else if (net_ratelimit())
-               printk(KERN_ERR "%s: %s\n", dev->ofdev->dev.of_node->full_name,
-                       error);
+               printk(KERN_ERR "%pOF: %s\n", dev->ofdev->dev.of_node, error);
 }
 
 /* EMAC PHY clock workaround:
@@ -2258,8 +2257,8 @@ static void emac_ethtool_get_drvinfo(struct net_device *ndev,
 
        strlcpy(info->driver, "ibm_emac", sizeof(info->driver));
        strlcpy(info->version, DRV_VERSION, sizeof(info->version));
-       snprintf(info->bus_info, sizeof(info->bus_info), "PPC 4xx EMAC-%d %s",
-                dev->cell_index, dev->ofdev->dev.of_node->full_name);
+       snprintf(info->bus_info, sizeof(info->bus_info), "PPC 4xx EMAC-%d %pOF",
+                dev->cell_index, dev->ofdev->dev.of_node);
 }
 
 static const struct ethtool_ops emac_ethtool_ops = {
@@ -2431,8 +2430,8 @@ static int emac_read_uint_prop(struct device_node *np, const char *name,
        const u32 *prop = of_get_property(np, name, &len);
        if (prop == NULL || len < sizeof(u32)) {
                if (fatal)
-                       printk(KERN_ERR "%s: missing %s property\n",
-                              np->full_name, name);
+                       printk(KERN_ERR "%pOF: missing %s property\n",
+                              np, name);
                return -ENODEV;
        }
        *val = *prop;
@@ -2768,7 +2767,7 @@ static int emac_init_phy(struct emac_instance *dev)
 #endif
        mutex_unlock(&emac_phy_map_lock);
        if (i == 0x20) {
-               printk(KERN_WARNING "%s: can't find PHY!\n", np->full_name);
+               printk(KERN_WARNING "%pOF: can't find PHY!\n", np);
                return -ENXIO;
        }
 
@@ -2894,8 +2893,8 @@ static int emac_init_config(struct emac_instance *dev)
 #ifdef CONFIG_IBM_EMAC_NO_FLOW_CTRL
                        dev->features |= EMAC_FTR_NO_FLOW_CONTROL_40x;
 #else
-                       printk(KERN_ERR "%s: Flow control not disabled!\n",
-                                       np->full_name);
+                       printk(KERN_ERR "%pOF: Flow control not disabled!\n",
+                                       np);
                        return -ENXIO;
 #endif
                }
@@ -2918,8 +2917,7 @@ static int emac_init_config(struct emac_instance *dev)
 #ifdef CONFIG_IBM_EMAC_TAH
                dev->features |= EMAC_FTR_HAS_TAH;
 #else
-               printk(KERN_ERR "%s: TAH support not enabled !\n",
-                      np->full_name);
+               printk(KERN_ERR "%pOF: TAH support not enabled !\n", np);
                return -ENXIO;
 #endif
        }
@@ -2928,8 +2926,7 @@ static int emac_init_config(struct emac_instance *dev)
 #ifdef CONFIG_IBM_EMAC_ZMII
                dev->features |= EMAC_FTR_HAS_ZMII;
 #else
-               printk(KERN_ERR "%s: ZMII support not enabled !\n",
-                      np->full_name);
+               printk(KERN_ERR "%pOF: ZMII support not enabled !\n", np);
                return -ENXIO;
 #endif
        }
@@ -2938,8 +2935,7 @@ static int emac_init_config(struct emac_instance *dev)
 #ifdef CONFIG_IBM_EMAC_RGMII
                dev->features |= EMAC_FTR_HAS_RGMII;
 #else
-               printk(KERN_ERR "%s: RGMII support not enabled !\n",
-                      np->full_name);
+               printk(KERN_ERR "%pOF: RGMII support not enabled !\n", np);
                return -ENXIO;
 #endif
        }
@@ -2947,8 +2943,8 @@ static int emac_init_config(struct emac_instance *dev)
        /* Read MAC-address */
        p = of_get_property(np, "local-mac-address", NULL);
        if (p == NULL) {
-               printk(KERN_ERR "%s: Can't find local-mac-address property\n",
-                      np->full_name);
+               printk(KERN_ERR "%pOF: Can't find local-mac-address property\n",
+                      np);
                return -ENXIO;
        }
        memcpy(dev->ndev->dev_addr, p, ETH_ALEN);
@@ -3043,23 +3039,21 @@ static int emac_probe(struct platform_device *ofdev)
        dev->emac_irq = irq_of_parse_and_map(np, 0);
        dev->wol_irq = irq_of_parse_and_map(np, 1);
        if (!dev->emac_irq) {
-               printk(KERN_ERR "%s: Can't map main interrupt\n", np->full_name);
+               printk(KERN_ERR "%pOF: Can't map main interrupt\n", np);
                goto err_free;
        }
        ndev->irq = dev->emac_irq;
 
        /* Map EMAC regs */
        if (of_address_to_resource(np, 0, &dev->rsrc_regs)) {
-               printk(KERN_ERR "%s: Can't get registers address\n",
-                      np->full_name);
+               printk(KERN_ERR "%pOF: Can't get registers address\n", np);
                goto err_irq_unmap;
        }
        // TODO : request_mem_region
        dev->emacp = ioremap(dev->rsrc_regs.start,
                             resource_size(&dev->rsrc_regs));
        if (dev->emacp == NULL) {
-               printk(KERN_ERR "%s: Can't map device registers!\n",
-                      np->full_name);
+               printk(KERN_ERR "%pOF: Can't map device registers!\n", np);
                err = -ENOMEM;
                goto err_irq_unmap;
        }
@@ -3068,8 +3062,7 @@ static int emac_probe(struct platform_device *ofdev)
        err = emac_wait_deps(dev);
        if (err) {
                printk(KERN_ERR
-                      "%s: Timeout waiting for dependent devices\n",
-                      np->full_name);
+                      "%pOF: Timeout waiting for dependent devices\n", np);
                /*  display more info about what's missing ? */
                goto err_reg_unmap;
        }
@@ -3084,8 +3077,8 @@ static int emac_probe(struct platform_device *ofdev)
        dev->commac.rx_chan_mask = MAL_CHAN_MASK(dev->mal_rx_chan);
        err = mal_register_commac(dev->mal, &dev->commac);
        if (err) {
-               printk(KERN_ERR "%s: failed to register with mal %s!\n",
-                      np->full_name, dev->mal_dev->dev.of_node->full_name);
+               printk(KERN_ERR "%pOF: failed to register with mal %pOF!\n",
+                      np, dev->mal_dev->dev.of_node);
                goto err_rel_deps;
        }
        dev->rx_skb_size = emac_rx_skb_size(ndev->mtu);
@@ -3161,8 +3154,8 @@ static int emac_probe(struct platform_device *ofdev)
 
        err = register_netdev(ndev);
        if (err) {
-               printk(KERN_ERR "%s: failed to register net device (%d)!\n",
-                      np->full_name, err);
+               printk(KERN_ERR "%pOF: failed to register net device (%d)!\n",
+                      np, err);
                goto err_detach_tah;
        }
 
@@ -3176,8 +3169,8 @@ static int emac_probe(struct platform_device *ofdev)
        wake_up_all(&emac_probe_wait);
 
 
-       printk(KERN_INFO "%s: EMAC-%d %s, MAC %pM\n",
-              ndev->name, dev->cell_index, np->full_name, ndev->dev_addr);
+       printk(KERN_INFO "%s: EMAC-%d %pOF, MAC %pM\n",
+              ndev->name, dev->cell_index, np, ndev->dev_addr);
 
        if (dev->phy_mode == PHY_MODE_SGMII)
                printk(KERN_NOTICE "%s: in SGMII mode\n", ndev->name);
index 5bdfc174a07e2cb25b040dbb1d14a00f5abb2852..9d06d3be3161b2a8c20d13f26bcc40b32cae155f 100644 (file)
@@ -31,7 +31,7 @@
 #endif
 
 #define EMAC_DBG(d, name, fmt, arg...) \
-       printk(KERN_DEBUG #name "%s: " fmt, d->ofdev->dev.of_node->full_name, ## arg)
+       printk(KERN_DEBUG #name "%pOF: " fmt, d->ofdev->dev.of_node, ## arg)
 
 #if DBG_LEVEL > 0
 #  define DBG(d,f,x...)                EMAC_DBG(d, emac, f, ##x)
index 91b1a558f37d65d218404c802c8e932c8828f43b..2c74baa2398a016fb9468f8a1b4b3aa5d0dc2a05 100644 (file)
@@ -579,8 +579,8 @@ static int mal_probe(struct platform_device *ofdev)
                mal->features |= (MAL_FTR_CLEAR_ICINTSTAT |
                                MAL_FTR_COMMON_ERR_INT);
 #else
-               printk(KERN_ERR "%s: Support for 405EZ not enabled!\n",
-                               ofdev->dev.of_node->full_name);
+               printk(KERN_ERR "%pOF: Support for 405EZ not enabled!\n",
+                               ofdev->dev.of_node);
                err = -ENODEV;
                goto fail;
 #endif
@@ -687,8 +687,8 @@ static int mal_probe(struct platform_device *ofdev)
        mal_enable_eob_irq(mal);
 
        printk(KERN_INFO
-              "MAL v%d %s, %d TX channels, %d RX channels\n",
-              mal->version, ofdev->dev.of_node->full_name,
+              "MAL v%d %pOF, %d TX channels, %d RX channels\n",
+              mal->version, ofdev->dev.of_node,
               mal->num_tx_chans, mal->num_rx_chans);
 
        /* Advertise this instance to the rest of the world */
index 206ccbbae7bb474ce34a4c3ea0a3cfe7888adc6d..c4a1ac38bba8b0193d5ce15093023087bc8a4337 100644 (file)
@@ -104,8 +104,8 @@ int rgmii_attach(struct platform_device *ofdev, int input, int mode)
 
        /* Check if we need to attach to a RGMII */
        if (input < 0 || !rgmii_valid_mode(mode)) {
-               printk(KERN_ERR "%s: unsupported settings !\n",
-                      ofdev->dev.of_node->full_name);
+               printk(KERN_ERR "%pOF: unsupported settings !\n",
+                      ofdev->dev.of_node);
                return -ENODEV;
        }
 
@@ -114,8 +114,8 @@ int rgmii_attach(struct platform_device *ofdev, int input, int mode)
        /* Enable this input */
        out_be32(&p->fer, in_be32(&p->fer) | rgmii_mode_mask(mode, input));
 
-       printk(KERN_NOTICE "%s: input %d in %s mode\n",
-              ofdev->dev.of_node->full_name, input, rgmii_mode_name(mode));
+       printk(KERN_NOTICE "%pOF: input %d in %s mode\n",
+              ofdev->dev.of_node, input, rgmii_mode_name(mode));
 
        ++dev->users;
 
@@ -249,8 +249,7 @@ static int rgmii_probe(struct platform_device *ofdev)
 
        rc = -ENXIO;
        if (of_address_to_resource(np, 0, &regs)) {
-               printk(KERN_ERR "%s: Can't get registers address\n",
-                      np->full_name);
+               printk(KERN_ERR "%pOF: Can't get registers address\n", np);
                goto err_free;
        }
 
@@ -258,8 +257,7 @@ static int rgmii_probe(struct platform_device *ofdev)
        dev->base = (struct rgmii_regs __iomem *)ioremap(regs.start,
                                                 sizeof(struct rgmii_regs));
        if (dev->base == NULL) {
-               printk(KERN_ERR "%s: Can't map device registers!\n",
-                      np->full_name);
+               printk(KERN_ERR "%pOF: Can't map device registers!\n", np);
                goto err_free;
        }
 
@@ -278,8 +276,8 @@ static int rgmii_probe(struct platform_device *ofdev)
        out_be32(&dev->base->fer, 0);
 
        printk(KERN_INFO
-              "RGMII %s initialized with%s MDIO support\n",
-              ofdev->dev.of_node->full_name,
+              "RGMII %pOF initialized with%s MDIO support\n",
+              ofdev->dev.of_node,
               (dev->flags & EMAC_RGMII_FLAG_HAS_MDIO) ? "" : "out");
 
        wmb();
index 32cb6c9007c55c959f36eb6bc58a7e8d53236ebe..9912456dca48f1e2ca5b5e6739e6f51daf6ef3aa 100644 (file)
@@ -58,8 +58,7 @@ void tah_reset(struct platform_device *ofdev)
                --n;
 
        if (unlikely(!n))
-               printk(KERN_ERR "%s: reset timeout\n",
-                       ofdev->dev.of_node->full_name);
+               printk(KERN_ERR "%pOF: reset timeout\n", ofdev->dev.of_node);
 
        /* 10KB TAH TX FIFO accommodates the max MTU of 9000 */
        out_be32(&p->mr,
@@ -105,8 +104,7 @@ static int tah_probe(struct platform_device *ofdev)
 
        rc = -ENXIO;
        if (of_address_to_resource(np, 0, &regs)) {
-               printk(KERN_ERR "%s: Can't get registers address\n",
-                      np->full_name);
+               printk(KERN_ERR "%pOF: Can't get registers address\n", np);
                goto err_free;
        }
 
@@ -114,8 +112,7 @@ static int tah_probe(struct platform_device *ofdev)
        dev->base = (struct tah_regs __iomem *)ioremap(regs.start,
                                               sizeof(struct tah_regs));
        if (dev->base == NULL) {
-               printk(KERN_ERR "%s: Can't map device registers!\n",
-                      np->full_name);
+               printk(KERN_ERR "%pOF: Can't map device registers!\n", np);
                goto err_free;
        }
 
@@ -124,8 +121,7 @@ static int tah_probe(struct platform_device *ofdev)
        /* Initialize TAH and enable IPv4 checksum verification, no TSO yet */
        tah_reset(ofdev);
 
-       printk(KERN_INFO
-              "TAH %s initialized\n", ofdev->dev.of_node->full_name);
+       printk(KERN_INFO "TAH %pOF initialized\n", ofdev->dev.of_node);
        wmb();
 
        return 0;
index 8727b865ea0219949b77f49f7f3547ec575bf1a6..89c42d362292fbd61f19ecb2a70a27a65eb6cefa 100644 (file)
@@ -121,15 +121,15 @@ int zmii_attach(struct platform_device *ofdev, int input, int *mode)
                } else
                        dev->mode = *mode;
 
-               printk(KERN_NOTICE "%s: bridge in %s mode\n",
-                      ofdev->dev.of_node->full_name,
+               printk(KERN_NOTICE "%pOF: bridge in %s mode\n",
+                      ofdev->dev.of_node,
                       zmii_mode_name(dev->mode));
        } else {
                /* All inputs must use the same mode */
                if (*mode != PHY_MODE_NA && *mode != dev->mode) {
                        printk(KERN_ERR
-                              "%s: invalid mode %d specified for input %d\n",
-                              ofdev->dev.of_node->full_name, *mode, input);
+                              "%pOF: invalid mode %d specified for input %d\n",
+                              ofdev->dev.of_node, *mode, input);
                        mutex_unlock(&dev->lock);
                        return -EINVAL;
                }
@@ -250,8 +250,7 @@ static int zmii_probe(struct platform_device *ofdev)
 
        rc = -ENXIO;
        if (of_address_to_resource(np, 0, &regs)) {
-               printk(KERN_ERR "%s: Can't get registers address\n",
-                      np->full_name);
+               printk(KERN_ERR "%pOF: Can't get registers address\n", np);
                goto err_free;
        }
 
@@ -259,8 +258,7 @@ static int zmii_probe(struct platform_device *ofdev)
        dev->base = (struct zmii_regs __iomem *)ioremap(regs.start,
                                                sizeof(struct zmii_regs));
        if (dev->base == NULL) {
-               printk(KERN_ERR "%s: Can't map device registers!\n",
-                      np->full_name);
+               printk(KERN_ERR "%pOF: Can't map device registers!\n", np);
                goto err_free;
        }
 
@@ -270,8 +268,7 @@ static int zmii_probe(struct platform_device *ofdev)
        /* Disable all inputs by default */
        out_be32(&dev->base->fer, 0);
 
-       printk(KERN_INFO
-              "ZMII %s initialized\n", ofdev->dev.of_node->full_name);
+       printk(KERN_INFO "ZMII %pOF initialized\n", ofdev->dev.of_node);
        wmb();
        platform_set_drvdata(ofdev, dev);
 
index 4bb04aaf9650e3c1973dcd85eea57239477b419d..6a4e8e1bbd90e5028ac147f3134a8ec2348d0bb5 100644 (file)
@@ -9221,8 +9221,7 @@ static int niu_get_of_props(struct niu *np)
 
        phy_type = of_get_property(dp, "phy-type", &prop_len);
        if (!phy_type) {
-               netdev_err(dev, "%s: OF node lacks phy-type property\n",
-                          dp->full_name);
+               netdev_err(dev, "%pOF: OF node lacks phy-type property\n", dp);
                return -EINVAL;
        }
 
@@ -9232,26 +9231,25 @@ static int niu_get_of_props(struct niu *np)
        strcpy(np->vpd.phy_type, phy_type);
 
        if (niu_phy_type_prop_decode(np, np->vpd.phy_type)) {
-               netdev_err(dev, "%s: Illegal phy string [%s]\n",
-                          dp->full_name, np->vpd.phy_type);
+               netdev_err(dev, "%pOF: Illegal phy string [%s]\n",
+                          dp, np->vpd.phy_type);
                return -EINVAL;
        }
 
        mac_addr = of_get_property(dp, "local-mac-address", &prop_len);
        if (!mac_addr) {
-               netdev_err(dev, "%s: OF node lacks local-mac-address property\n",
-                          dp->full_name);
+               netdev_err(dev, "%pOF: OF node lacks local-mac-address property\n",
+                          dp);
                return -EINVAL;
        }
        if (prop_len != dev->addr_len) {
-               netdev_err(dev, "%s: OF MAC address prop len (%d) is wrong\n",
-                          dp->full_name, prop_len);
+               netdev_err(dev, "%pOF: OF MAC address prop len (%d) is wrong\n",
+                          dp, prop_len);
        }
        memcpy(dev->dev_addr, mac_addr, dev->addr_len);
        if (!is_valid_ether_addr(&dev->dev_addr[0])) {
-               netdev_err(dev, "%s: OF MAC address is invalid\n",
-                          dp->full_name);
-               netdev_err(dev, "%s: [ %pM ]\n", dp->full_name, dev->dev_addr);
+               netdev_err(dev, "%pOF: OF MAC address is invalid\n", dp);
+               netdev_err(dev, "%pOF: [ %pM ]\n", dp, dev->dev_addr);
                return -EINVAL;
        }
 
@@ -10027,8 +10025,8 @@ static int niu_of_probe(struct platform_device *op)
 
        reg = of_get_property(op->dev.of_node, "reg", NULL);
        if (!reg) {
-               dev_err(&op->dev, "%s: No 'reg' property, aborting\n",
-                       op->dev.of_node->full_name);
+               dev_err(&op->dev, "%pOF: No 'reg' property, aborting\n",
+                       op->dev.of_node);
                return -ENODEV;
        }
 
index badd0a8caeb9e85d26a16d48b0eb892123276aaf..c8776dbf1a55adc23bf5ce9c0b43c8867f72af93 100644 (file)
@@ -1321,8 +1321,8 @@ static void cpsw_slave_open(struct cpsw_slave *slave, struct cpsw_priv *priv)
                phy = of_phy_connect(priv->ndev, slave->data->phy_node,
                                 &cpsw_adjust_link, 0, slave->data->phy_if);
                if (!phy) {
-                       dev_err(priv->dev, "phy \"%s\" not found on slave %d\n",
-                               slave->data->phy_node->full_name,
+                       dev_err(priv->dev, "phy \"%pOF\" not found on slave %d\n",
+                               slave->data->phy_node,
                                slave->slave_num);
                        return;
                }
@@ -2670,8 +2670,8 @@ static int cpsw_probe_dt(struct cpsw_platform_data *data,
                parp = of_get_property(slave_node, "phy_id", &lenp);
                if (slave_data->phy_node) {
                        dev_dbg(&pdev->dev,
-                               "slave[%d] using phy-handle=\"%s\"\n",
-                               i, slave_data->phy_node->full_name);
+                               "slave[%d] using phy-handle=\"%pOF\"\n",
+                               i, slave_data->phy_node);
                } else if (of_phy_is_fixed_link(slave_node)) {
                        /* In the case of a fixed PHY, the DT node associated
                         * to the PHY is the Ethernet MAC DT node.
index 64d5527feb2ac20c3229c667d806039050f03a0a..4bb561856af53c0165e1d052a7ebfa2bd279ce68 100644 (file)
@@ -1480,8 +1480,8 @@ static int emac_dev_open(struct net_device *ndev)
                phydev = of_phy_connect(ndev, priv->phy_node,
                                        &emac_adjust_link, 0, 0);
                if (!phydev) {
-                       dev_err(emac_dev, "could not connect to phy %s\n",
-                               priv->phy_node->full_name);
+                       dev_err(emac_dev, "could not connect to phy %pOF\n",
+                               priv->phy_node);
                        ret = -ENODEV;
                        goto err;
                }
index d73da8afe08e79d6d2309a0f88f184fb8162137e..60abc9250f56a7eac7025447626799e3b046c8f5 100644 (file)
@@ -1089,7 +1089,7 @@ static int temac_of_probe(struct platform_device *op)
 
        lp->phy_node = of_parse_phandle(op->dev.of_node, "phy-handle", 0);
        if (lp->phy_node)
-               dev_dbg(lp->dev, "using PHY node %s (%p)\n", np->full_name, np);
+               dev_dbg(lp->dev, "using PHY node %pOF (%p)\n", np, np);
 
        /* Add the device attributes */
        rc = sysfs_create_group(&lp->dev->kobj, &temac_attr_group);
index 6a33646bdf05d5af5455ea2b2862e5bd22a70008..c3825c7da0381aadd3096c7bca83eedefe407344 100644 (file)
@@ -105,7 +105,7 @@ static int mdio_mux_mmioreg_probe(struct platform_device *pdev)
        const __be32 *iprop;
        int len, ret;
 
-       dev_dbg(&pdev->dev, "probing node %s\n", np->full_name);
+       dev_dbg(&pdev->dev, "probing node %pOF\n", np);
 
        s = devm_kzalloc(&pdev->dev, sizeof(*s), GFP_KERNEL);
        if (!s)
@@ -113,8 +113,8 @@ static int mdio_mux_mmioreg_probe(struct platform_device *pdev)
 
        ret = of_address_to_resource(np, 0, &res);
        if (ret) {
-               dev_err(&pdev->dev, "could not obtain memory map for node %s\n",
-                       np->full_name);
+               dev_err(&pdev->dev, "could not obtain memory map for node %pOF\n",
+                       np);
                return ret;
        }
        s->phys = res.start;
@@ -145,15 +145,15 @@ static int mdio_mux_mmioreg_probe(struct platform_device *pdev)
        for_each_available_child_of_node(np, np2) {
                iprop = of_get_property(np2, "reg", &len);
                if (!iprop || len != sizeof(uint32_t)) {
-                       dev_err(&pdev->dev, "mdio-mux child node %s is "
-                               "missing a 'reg' property\n", np2->full_name);
+                       dev_err(&pdev->dev, "mdio-mux child node %pOF is "
+                               "missing a 'reg' property\n", np2);
                        of_node_put(np2);
                        return -ENODEV;
                }
                if (be32_to_cpup(iprop) & ~s->mask) {
-                       dev_err(&pdev->dev, "mdio-mux child node %s has "
+                       dev_err(&pdev->dev, "mdio-mux child node %pOF has "
                                "a 'reg' value with unmasked bits\n",
-                               np2->full_name);
+                               np2);
                        of_node_put(np2);
                        return -ENODEV;
                }
@@ -162,8 +162,8 @@ static int mdio_mux_mmioreg_probe(struct platform_device *pdev)
        ret = mdio_mux_init(&pdev->dev, mdio_mux_mmioreg_switch_fn,
                            &s->mux_handle, s, NULL);
        if (ret) {
-               dev_err(&pdev->dev, "failed to register mdio-mux bus %s\n",
-                       np->full_name);
+               dev_err(&pdev->dev, "failed to register mdio-mux bus %pOF\n",
+                       np);
                return ret;
        }
 
index c608e1dfaf09745a5ba25aabfbcf7d8c20819e23..942ceaf3fd3f4d3d999b3fdc044b0ee165e3bd8e 100644 (file)
@@ -138,16 +138,16 @@ int mdio_mux_init(struct device *dev,
                r = of_property_read_u32(child_bus_node, "reg", &v);
                if (r) {
                        dev_err(dev,
-                               "Error: Failed to find reg for child %s\n",
-                               of_node_full_name(child_bus_node));
+                               "Error: Failed to find reg for child %pOF\n",
+                               child_bus_node);
                        continue;
                }
 
                cb = devm_kzalloc(dev, sizeof(*cb), GFP_KERNEL);
                if (cb == NULL) {
                        dev_err(dev,
-                               "Error: Failed to allocate memory for child %s\n",
-                               of_node_full_name(child_bus_node));
+                               "Error: Failed to allocate memory for child %pOF\n",
+                               child_bus_node);
                        ret_val = -ENOMEM;
                        continue;
                }
@@ -157,8 +157,8 @@ int mdio_mux_init(struct device *dev,
                cb->mii_bus = mdiobus_alloc();
                if (!cb->mii_bus) {
                        dev_err(dev,
-                               "Error: Failed to allocate MDIO bus for child %s\n",
-                               of_node_full_name(child_bus_node));
+                               "Error: Failed to allocate MDIO bus for child %pOF\n",
+                               child_bus_node);
                        ret_val = -ENOMEM;
                        devm_kfree(dev, cb);
                        continue;
@@ -174,8 +174,8 @@ int mdio_mux_init(struct device *dev,
                r = of_mdiobus_register(cb->mii_bus, child_bus_node);
                if (r) {
                        dev_err(dev,
-                               "Error: Failed to register MDIO bus for child %s\n",
-                               of_node_full_name(child_bus_node));
+                               "Error: Failed to register MDIO bus for child %pOF\n",
+                               child_bus_node);
                        mdiobus_free(cb->mii_bus);
                        devm_kfree(dev, cb);
                } else {