net/mdio-uclass.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * (C) Copyright 2019
   4  * Alex Marginean, NXP
   5  */
   6
   7 #include <common.h>
   8 #include <dm.h>
   9 #include <log.h>
  10 #include <malloc.h>
  11 #include <miiphy.h>
  12 #include <dm/device-internal.h>
  13 #include <dm/device_compat.h>
  14 #include <dm/of_extra.h>
  15 #include <dm/uclass-internal.h>
  16 #include <linux/compat.h>
  17
  18 void dm_mdio_probe_devices(void)
  19 {
  20         struct udevice *it;
  21         struct uclass *uc;
  22
  23         uclass_get(UCLASS_MDIO, &uc);
  24         uclass_foreach_dev(it, uc) {
  25                 device_probe(it);
  26         }
  27 }
  28
  29 static int dm_mdio_post_bind(struct udevice *dev)
  30 {
  31         const char *dt_name;
  32
  33         /* set a custom name for the MDIO device, if present in DT */
  34         if (dev_has_ofnode(dev)) {
  35                 dt_name = dev_read_string(dev, "device-name");
  36                 if (dt_name) {
  37                         debug("renaming dev %s to %s\n", dev->name, dt_name);
  38                         device_set_name(dev, dt_name);
  39                 }
  40         }
  41
  42         /*
  43          * MDIO command doesn't like spaces in names, don't allow them to keep
  44          * it happy
  45          */
  46         if (strchr(dev->name, ' ')) {
  47                 debug("\nError: MDIO device name \"%s\" has a space!\n",
  48                       dev->name);
  49                 return -EINVAL;
  50         }
  51
  52 #if CONFIG_IS_ENABLED(OF_REAL)
  53         return dm_scan_fdt_dev(dev);
  54 #else
  55         return 0;
  56 #endif
  57 }
  58
  59 int dm_mdio_read(struct udevice *mdio_dev, int addr, int devad, int reg)
  60 {
  61         struct mdio_ops *ops = mdio_get_ops(mdio_dev);
  62
  63         if (!ops->read)
  64                 return -ENOSYS;
  65
  66         return ops->read(mdio_dev, addr, devad, reg);
  67 }
  68
  69 int dm_mdio_write(struct udevice *mdio_dev, int addr, int devad, int reg,
  70                   u16 val)
  71 {
  72         struct mdio_ops *ops = mdio_get_ops(mdio_dev);
  73
  74         if (!ops->write)
  75                 return -ENOSYS;
  76
  77         return ops->write(mdio_dev, addr, devad, reg, val);
  78 }
  79
  80 int dm_mdio_reset(struct udevice *mdio_dev)
  81 {
  82         struct mdio_ops *ops = mdio_get_ops(mdio_dev);
  83
  84         if (!ops->reset)
  85                 return 0;
  86
  87         return ops->reset(mdio_dev);
  88 }
  89
  90 /*
  91  * Following read/write/reset functions are registered with legacy MII code.
  92  * These are called for PHY operations by upper layers and we further call the
  93  * DM MDIO driver functions.
  94  */
  95 static int mdio_read(struct mii_dev *mii_bus, int addr, int devad, int reg)
  96 {
  97         return dm_mdio_read(mii_bus->priv, addr, devad, reg);
  98 }
  99
 100 static int mdio_write(struct mii_dev *mii_bus, int addr, int devad, int reg,
 101                       u16 val)
 102 {
 103         return dm_mdio_write(mii_bus->priv, addr, devad, reg, val);
 104 }
 105
 106 static int mdio_reset(struct mii_dev *mii_bus)
 107 {
 108         return dm_mdio_reset(mii_bus->priv);
 109 }
 110
 111 static int dm_mdio_post_probe(struct udevice *dev)
 112 {
 113         struct mdio_perdev_priv *pdata = dev_get_uclass_priv(dev);
 114
 115         pdata->mii_bus = mdio_alloc();
 116         pdata->mii_bus->read = mdio_read;
 117         pdata->mii_bus->write = mdio_write;
 118         pdata->mii_bus->reset = mdio_reset;
 119         pdata->mii_bus->priv = dev;
 120         strlcpy(pdata->mii_bus->name, dev->name, MDIO_NAME_LEN);
 121
 122         return mdio_register(pdata->mii_bus);
 123 }
 124
 125 static int dm_mdio_pre_remove(struct udevice *dev)
 126 {
 127         struct mdio_perdev_priv *pdata = dev_get_uclass_priv(dev);
 128
 129         dm_mdio_reset(dev);
 130         mdio_unregister(pdata->mii_bus);
 131         mdio_free(pdata->mii_bus);
 132
 133         return 0;
 134 }
 135
 136 struct phy_device *dm_phy_find_by_ofnode(ofnode phynode)
 137 {
 138         struct mdio_perdev_priv *pdata;
 139         struct udevice *mdiodev;
 140         u32 phy_addr;
 141
 142         if (ofnode_read_u32(phynode, "reg", &phy_addr))
 143                 return NULL;
 144
 145         if (uclass_get_device_by_ofnode(UCLASS_MDIO,
 146                                         ofnode_get_parent(phynode),
 147                                         &mdiodev))
 148                 return NULL;
 149
 150         if (device_probe(mdiodev))
 151                 return NULL;
 152
 153         pdata = dev_get_uclass_priv(mdiodev);
 154
 155         return phy_find_by_mask(pdata->mii_bus, BIT(phy_addr));
 156 }
 157
 158 struct phy_device *dm_mdio_phy_connect(struct udevice *mdiodev, int phyaddr,
 159                                        struct udevice *ethdev,
 160                                        phy_interface_t interface)
 161 {
 162         struct mdio_perdev_priv *pdata = dev_get_uclass_priv(mdiodev);
 163
 164         if (device_probe(mdiodev))
 165                 return NULL;
 166
 167         return phy_connect(pdata->mii_bus, phyaddr, ethdev, interface);
 168 }
 169
 170 static struct phy_device *dm_eth_connect_phy_handle(struct udevice *ethdev,
 171                                                     phy_interface_t interface)
 172 {
 173         u32 phy_addr;
 174         struct udevice *mdiodev;
 175         struct phy_device *phy;
 176         ofnode phynode;
 177
 178         if (IS_ENABLED(CONFIG_PHY_FIXED) &&
 179             ofnode_phy_is_fixed_link(dev_ofnode(ethdev), &phynode)) {
 180                 phy = phy_connect(NULL, 0, ethdev, interface);
 181                 goto out;
 182         }
 183
 184         phynode = dev_get_phy_node(ethdev);
 185         if (!ofnode_valid(phynode)) {
 186                 dev_dbg(ethdev, "can't find PHY node\n");
 187                 return NULL;
 188         }
 189
 190         /*
 191          * reading 'reg' directly should be fine.  This is a PHY node, the
 192          * address is always size 1 and requires no translation
 193          */
 194         if (ofnode_read_u32(phynode, "reg", &phy_addr)) {
 195                 dev_dbg(ethdev, "missing reg property in phy node\n");
 196                 return NULL;
 197         }
 198
 199         if (uclass_get_device_by_ofnode(UCLASS_MDIO,
 200                                         ofnode_get_parent(phynode),
 201                                         &mdiodev)) {
 202                 dev_dbg(ethdev, "can't find MDIO bus for node %s\n",
 203                         ofnode_get_name(ofnode_get_parent(phynode)));
 204                 return NULL;
 205         }
 206
 207         phy = dm_mdio_phy_connect(mdiodev, phy_addr, ethdev, interface);
 208
 209 out:
 210         if (phy)
 211                 phy->node = phynode;
 212
 213         return phy;
 214 }
 215
 216 /* Connect to a PHY linked in eth DT node */
 217 struct phy_device *dm_eth_phy_connect(struct udevice *ethdev)
 218 {
 219         phy_interface_t interface;
 220         struct phy_device *phy;
 221
 222         if (!dev_has_ofnode(ethdev)) {
 223                 debug("%s: supplied eth dev has no DT node!\n", ethdev->name);
 224                 return NULL;
 225         }
 226
 227         interface = dev_read_phy_mode(ethdev);
 228         if (interface == PHY_INTERFACE_MODE_NA)
 229                 dev_dbg(ethdev, "can't find interface mode, default to NA\n");
 230
 231         phy = dm_eth_connect_phy_handle(ethdev, interface);
 232
 233         if (!phy)
 234                 return NULL;
 235
 236         phy->interface = interface;
 237
 238         return phy;
 239 }
 240
 241 UCLASS_DRIVER(mdio) = {
 242         .id = UCLASS_MDIO,
 243         .name = "mdio",
 244         .post_bind  = dm_mdio_post_bind,
 245         .post_probe = dm_mdio_post_probe,
 246         .pre_remove = dm_mdio_pre_remove,
 247         .per_device_auto        = sizeof(struct mdio_perdev_priv),
 248 };