target/linux/ramips/files/drivers/net/ethernet/ralink/mdio.c

   1 /*   This program is free software; you can redistribute it and/or modify
   2  *   it under the terms of the GNU General Public License as published by
   3  *   the Free Software Foundation; version 2 of the License
   4  *
   5  *   Copyright (C) 2009-2015 John Crispin <blogic@openwrt.org>
   6  *   Copyright (C) 2009-2015 Felix Fietkau <nbd@nbd.name>
   7  *   Copyright (C) 2013-2015 Michael Lee <igvtee@gmail.com>
   8  */
   9
  10 #include <linux/module.h>
  11 #include <linux/kernel.h>
  12 #include <linux/phy.h>
  13 #include <linux/of_net.h>
  14 #include <linux/of_mdio.h>
  15
  16 #include "mtk_eth_soc.h"
  17 #include "mdio.h"
  18
  19 static int fe_mdio_reset(struct mii_bus *bus)
  20 {
  21         /* TODO */
  22         return 0;
  23 }
  24
  25 static void fe_phy_link_adjust(struct net_device *dev)
  26 {
  27         struct fe_priv *priv = netdev_priv(dev);
  28         unsigned long flags;
  29         int i;
  30
  31         spin_lock_irqsave(&priv->phy->lock, flags);
  32         for (i = 0; i < 8; i++) {
  33                 if (priv->phy->phy_node[i]) {
  34                         struct phy_device *phydev = priv->phy->phy[i];
  35                         int status_change = 0;
  36
  37                         if (phydev->link)
  38                                 if (priv->phy->duplex[i] != phydev->duplex ||
  39                                     priv->phy->speed[i] != phydev->speed)
  40                                         status_change = 1;
  41
  42                         if (phydev->link != priv->link[i])
  43                                 status_change = 1;
  44
  45                         switch (phydev->speed) {
  46                         case SPEED_1000:
  47                         case SPEED_100:
  48                         case SPEED_10:
  49                                 priv->link[i] = phydev->link;
  50                                 priv->phy->duplex[i] = phydev->duplex;
  51                                 priv->phy->speed[i] = phydev->speed;
  52
  53                                 if (status_change &&
  54                                     priv->soc->mdio_adjust_link)
  55                                         priv->soc->mdio_adjust_link(priv, i);
  56                                 break;
  57                         }
  58                 }
  59         }
  60         spin_unlock_irqrestore(&priv->phy->lock, flags);
  61 }
  62
  63 int fe_connect_phy_node(struct fe_priv *priv, struct device_node *phy_node, int port)
  64 {
  65         const __be32 *_phy_addr = NULL;
  66         struct phy_device *phydev;
  67 #if LINUX_VERSION_CODE < KERNEL_VERSION(5, 10, 0)
  68         int phy_mode;
  69 #else
  70         phy_interface_t phy_mode = PHY_INTERFACE_MODE_NA;
  71 #endif
  72
  73         _phy_addr = of_get_property(phy_node, "reg", NULL);
  74
  75         if (!_phy_addr || (be32_to_cpu(*_phy_addr) >= 0x20)) {
  76                 pr_err("%s: invalid phy id\n", phy_node->name);
  77                 return -EINVAL;
  78         }
  79
  80 #if LINUX_VERSION_CODE < KERNEL_VERSION(5, 10, 0)
  81         phy_mode = of_get_phy_mode(phy_node);
  82         if (phy_mode < 0) {
  83 #else
  84         of_get_phy_mode(phy_node, &phy_mode);
  85         if (phy_mode == PHY_INTERFACE_MODE_NA) {
  86 #endif
  87                 dev_err(priv->dev, "incorrect phy-mode %d\n", phy_mode);
  88                 priv->phy->phy_node[port] = NULL;
  89                 return -EINVAL;
  90         }
  91
  92         phydev = of_phy_connect(priv->netdev, phy_node, fe_phy_link_adjust,
  93                                 0, phy_mode);
  94         if (!phydev) {
  95                 dev_err(priv->dev, "could not connect to PHY\n");
  96                 priv->phy->phy_node[port] = NULL;
  97                 return -ENODEV;
  98         }
  99
 100         phy_set_max_speed(phydev, SPEED_1000);
 101         linkmode_copy(phydev->advertising, phydev->supported);
 102         phydev->no_auto_carrier_off = 1;
 103
 104         dev_info(priv->dev,
 105                  "connected port %d to PHY at %s [uid=%08x, driver=%s]\n",
 106                  port, dev_name(&phydev->mdio.dev), phydev->phy_id,
 107                  phydev->drv->name);
 108
 109         priv->phy->phy[port] = phydev;
 110         priv->link[port] = 0;
 111
 112         return 0;
 113 }
 114
 115 static void phy_init(struct fe_priv *priv, struct phy_device *phy)
 116 {
 117         phy_attach(priv->netdev, dev_name(&phy->mdio.dev), PHY_INTERFACE_MODE_MII);
 118
 119         phy->autoneg = AUTONEG_ENABLE;
 120         phy->speed = 0;
 121         phy->duplex = 0;
 122
 123         phy_set_max_speed(phy, IS_ENABLED(CONFIG_NET_RALINK_MDIO_MT7620) ?
 124                                        SPEED_1000 :
 125                                        SPEED_100);
 126         linkmode_copy(phy->advertising, phy->supported);
 127         linkmode_set_bit(ETHTOOL_LINK_MODE_Autoneg_BIT, phy->advertising);
 128
 129         phy_start_aneg(phy);
 130 }
 131
 132 static int fe_phy_connect(struct fe_priv *priv)
 133 {
 134         int i;
 135
 136         for (i = 0; i < 8; i++) {
 137                 if (priv->phy->phy_node[i]) {
 138                         if (!priv->phy_dev) {
 139                                 priv->phy_dev = priv->phy->phy[i];
 140                                 priv->phy_flags = FE_PHY_FLAG_PORT;
 141                         }
 142                 } else if (priv->mii_bus) {
 143                         struct phy_device *phydev;
 144
 145                         phydev = mdiobus_get_phy(priv->mii_bus, i);
 146                         if (!phydev || phydev->attached_dev)
 147                                 continue;
 148
 149                         phy_init(priv, phydev);
 150                         if (!priv->phy_dev) {
 151                                 priv->phy_dev = mdiobus_get_phy(priv->mii_bus, i);
 152                                 priv->phy_flags = FE_PHY_FLAG_ATTACH;
 153                         }
 154                 }
 155         }
 156
 157         return 0;
 158 }
 159
 160 static void fe_phy_disconnect(struct fe_priv *priv)
 161 {
 162         unsigned long flags;
 163         int i;
 164
 165         for (i = 0; i < 8; i++)
 166                 if (priv->phy->phy_fixed[i]) {
 167                         spin_lock_irqsave(&priv->phy->lock, flags);
 168                         priv->link[i] = 0;
 169                         if (priv->soc->mdio_adjust_link)
 170                                 priv->soc->mdio_adjust_link(priv, i);
 171                         spin_unlock_irqrestore(&priv->phy->lock, flags);
 172                 } else if (priv->phy->phy[i]) {
 173                         phy_disconnect(priv->phy->phy[i]);
 174                 } else if (priv->mii_bus && mdiobus_get_phy(priv->mii_bus, i)) {
 175                         phy_detach(mdiobus_get_phy(priv->mii_bus, i));
 176                 }
 177 }
 178
 179 static void fe_phy_start(struct fe_priv *priv)
 180 {
 181         unsigned long flags;
 182         int i;
 183
 184         for (i = 0; i < 8; i++) {
 185                 if (priv->phy->phy_fixed[i]) {
 186                         spin_lock_irqsave(&priv->phy->lock, flags);
 187                         priv->link[i] = 1;
 188                         if (priv->soc->mdio_adjust_link)
 189                                 priv->soc->mdio_adjust_link(priv, i);
 190                         spin_unlock_irqrestore(&priv->phy->lock, flags);
 191                 } else if (priv->phy->phy[i]) {
 192                         phy_start(priv->phy->phy[i]);
 193                 }
 194         }
 195 }
 196
 197 static void fe_phy_stop(struct fe_priv *priv)
 198 {
 199         unsigned long flags;
 200         int i;
 201
 202         for (i = 0; i < 8; i++)
 203                 if (priv->phy->phy_fixed[i]) {
 204                         spin_lock_irqsave(&priv->phy->lock, flags);
 205                         priv->link[i] = 0;
 206                         if (priv->soc->mdio_adjust_link)
 207                                 priv->soc->mdio_adjust_link(priv, i);
 208                         spin_unlock_irqrestore(&priv->phy->lock, flags);
 209                 } else if (priv->phy->phy[i]) {
 210                         phy_stop(priv->phy->phy[i]);
 211                 }
 212 }
 213
 214 static struct fe_phy phy_ralink = {
 215         .connect = fe_phy_connect,
 216         .disconnect = fe_phy_disconnect,
 217         .start = fe_phy_start,
 218         .stop = fe_phy_stop,
 219 };
 220
 221 int fe_mdio_init(struct fe_priv *priv)
 222 {
 223         struct device_node *mii_np;
 224         int err;
 225
 226         if (!priv->soc->mdio_read || !priv->soc->mdio_write)
 227                 return 0;
 228
 229         spin_lock_init(&phy_ralink.lock);
 230         priv->phy = &phy_ralink;
 231
 232         mii_np = of_get_child_by_name(priv->dev->of_node, "mdio-bus");
 233         if (!mii_np) {
 234                 dev_err(priv->dev, "no %s child node found", "mdio-bus");
 235                 return -ENODEV;
 236         }
 237
 238         if (!of_device_is_available(mii_np)) {
 239                 err = 0;
 240                 goto err_put_node;
 241         }
 242
 243         priv->mii_bus = mdiobus_alloc();
 244         if (!priv->mii_bus) {
 245                 err = -ENOMEM;
 246                 goto err_put_node;
 247         }
 248
 249         priv->mii_bus->name = "mdio";
 250         priv->mii_bus->read = priv->soc->mdio_read;
 251         priv->mii_bus->write = priv->soc->mdio_write;
 252         priv->mii_bus->reset = fe_mdio_reset;
 253         priv->mii_bus->priv = priv;
 254         priv->mii_bus->parent = priv->dev;
 255
 256         snprintf(priv->mii_bus->id, MII_BUS_ID_SIZE, "%s", mii_np->name);
 257         err = of_mdiobus_register(priv->mii_bus, mii_np);
 258         if (err)
 259                 goto err_free_bus;
 260
 261         return 0;
 262
 263 err_free_bus:
 264         kfree(priv->mii_bus);
 265 err_put_node:
 266         of_node_put(mii_np);
 267         priv->mii_bus = NULL;
 268         return err;
 269 }
 270
 271 void fe_mdio_cleanup(struct fe_priv *priv)
 272 {
 273         if (!priv->mii_bus)
 274                 return;
 275
 276         mdiobus_unregister(priv->mii_bus);
 277         of_node_put(priv->mii_bus->dev.of_node);
 278         kfree(priv->mii_bus);
 279 }