target/linux/ramips/files-4.14/drivers/net/ethernet/mtk/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 }
  61
  62 int fe_connect_phy_node(struct fe_priv *priv, struct device_node *phy_node)
  63 {
  64         const __be32 *_port = NULL;
  65         struct phy_device *phydev;
  66         int phy_mode, port;
  67
  68         _port = of_get_property(phy_node, "reg", NULL);
  69
  70         if (!_port || (be32_to_cpu(*_port) >= 0x20)) {
  71                 pr_err("%s: invalid port id\n", phy_node->name);
  72                 return -EINVAL;
  73         }
  74         port = be32_to_cpu(*_port);
  75         phy_mode = of_get_phy_mode(phy_node);
  76         if (phy_mode < 0) {
  77                 dev_err(priv->device, "incorrect phy-mode %d\n", phy_mode);
  78                 priv->phy->phy_node[port] = NULL;
  79                 return -EINVAL;
  80         }
  81
  82         phydev = of_phy_connect(priv->netdev, phy_node, fe_phy_link_adjust,
  83                                 0, phy_mode);
  84         if (IS_ERR(phydev)) {
  85                 dev_err(priv->device, "could not connect to PHY\n");
  86                 priv->phy->phy_node[port] = NULL;
  87                 return PTR_ERR(phydev);
  88         }
  89
  90         phydev->supported &= PHY_GBIT_FEATURES;
  91         phydev->advertising = phydev->supported;
  92         phydev->no_auto_carrier_off = 1;
  93
  94         dev_info(priv->device,
  95                  "connected port %d to PHY at %s [uid=%08x, driver=%s]\n",
  96                  port, dev_name(&phydev->mdio.dev), phydev->phy_id,
  97                  phydev->drv->name);
  98
  99         priv->phy->phy[port] = phydev;
 100         priv->link[port] = 0;
 101
 102         return 0;
 103 }
 104
 105 static void phy_init(struct fe_priv *priv, struct phy_device *phy)
 106 {
 107         phy_attach(priv->netdev, dev_name(&phy->mdio.dev), PHY_INTERFACE_MODE_MII);
 108
 109         phy->autoneg = AUTONEG_ENABLE;
 110         phy->speed = 0;
 111         phy->duplex = 0;
 112         phy->supported &= PHY_BASIC_FEATURES;
 113         phy->advertising = phy->supported | ADVERTISED_Autoneg;
 114
 115         phy_start_aneg(phy);
 116 }
 117
 118 static int fe_phy_connect(struct fe_priv *priv)
 119 {
 120         int i;
 121
 122         for (i = 0; i < 8; i++) {
 123                 if (priv->phy->phy_node[i]) {
 124                         if (!priv->phy_dev) {
 125                                 priv->phy_dev = priv->phy->phy[i];
 126                                 priv->phy_flags = FE_PHY_FLAG_PORT;
 127                         }
 128                 } else if (priv->mii_bus && mdiobus_get_phy(priv->mii_bus, i)) {
 129                         phy_init(priv, mdiobus_get_phy(priv->mii_bus, i));
 130                         if (!priv->phy_dev) {
 131                                 priv->phy_dev = mdiobus_get_phy(priv->mii_bus, i);
 132                                 priv->phy_flags = FE_PHY_FLAG_ATTACH;
 133                         }
 134                 }
 135         }
 136
 137         return 0;
 138 }
 139
 140 static void fe_phy_disconnect(struct fe_priv *priv)
 141 {
 142         unsigned long flags;
 143         int i;
 144
 145         for (i = 0; i < 8; i++)
 146                 if (priv->phy->phy_fixed[i]) {
 147                         spin_lock_irqsave(&priv->phy->lock, flags);
 148                         priv->link[i] = 0;
 149                         if (priv->soc->mdio_adjust_link)
 150                                 priv->soc->mdio_adjust_link(priv, i);
 151                         spin_unlock_irqrestore(&priv->phy->lock, flags);
 152                 } else if (priv->phy->phy[i]) {
 153                         phy_disconnect(priv->phy->phy[i]);
 154                 } else if (priv->mii_bus && mdiobus_get_phy(priv->mii_bus, i)) {
 155                         phy_detach(mdiobus_get_phy(priv->mii_bus, i));
 156                 }
 157 }
 158
 159 static void fe_phy_start(struct fe_priv *priv)
 160 {
 161         unsigned long flags;
 162         int i;
 163
 164         for (i = 0; i < 8; i++) {
 165                 if (priv->phy->phy_fixed[i]) {
 166                         spin_lock_irqsave(&priv->phy->lock, flags);
 167                         priv->link[i] = 1;
 168                         if (priv->soc->mdio_adjust_link)
 169                                 priv->soc->mdio_adjust_link(priv, i);
 170                         spin_unlock_irqrestore(&priv->phy->lock, flags);
 171                 } else if (priv->phy->phy[i]) {
 172                         phy_start(priv->phy->phy[i]);
 173                 }
 174         }
 175 }
 176
 177 static void fe_phy_stop(struct fe_priv *priv)
 178 {
 179         unsigned long flags;
 180         int i;
 181
 182         for (i = 0; i < 8; i++)
 183                 if (priv->phy->phy_fixed[i]) {
 184                         spin_lock_irqsave(&priv->phy->lock, flags);
 185                         priv->link[i] = 0;
 186                         if (priv->soc->mdio_adjust_link)
 187                                 priv->soc->mdio_adjust_link(priv, i);
 188                         spin_unlock_irqrestore(&priv->phy->lock, flags);
 189                 } else if (priv->phy->phy[i]) {
 190                         phy_stop(priv->phy->phy[i]);
 191                 }
 192 }
 193
 194 static struct fe_phy phy_ralink = {
 195         .connect = fe_phy_connect,
 196         .disconnect = fe_phy_disconnect,
 197         .start = fe_phy_start,
 198         .stop = fe_phy_stop,
 199 };
 200
 201 int fe_mdio_init(struct fe_priv *priv)
 202 {
 203         struct device_node *mii_np;
 204         int err;
 205
 206         if (!priv->soc->mdio_read || !priv->soc->mdio_write)
 207                 return 0;
 208
 209         spin_lock_init(&phy_ralink.lock);
 210         priv->phy = &phy_ralink;
 211
 212         mii_np = of_get_child_by_name(priv->device->of_node, "mdio-bus");
 213         if (!mii_np) {
 214                 dev_err(priv->device, "no %s child node found", "mdio-bus");
 215                 return -ENODEV;
 216         }
 217
 218         if (!of_device_is_available(mii_np)) {
 219                 err = 0;
 220                 goto err_put_node;
 221         }
 222
 223         priv->mii_bus = mdiobus_alloc();
 224         if (!priv->mii_bus) {
 225                 err = -ENOMEM;
 226                 goto err_put_node;
 227         }
 228
 229         priv->mii_bus->name = "mdio";
 230         priv->mii_bus->read = priv->soc->mdio_read;
 231         priv->mii_bus->write = priv->soc->mdio_write;
 232         priv->mii_bus->reset = fe_mdio_reset;
 233         priv->mii_bus->priv = priv;
 234         priv->mii_bus->parent = priv->device;
 235
 236         snprintf(priv->mii_bus->id, MII_BUS_ID_SIZE, "%s", mii_np->name);
 237         err = of_mdiobus_register(priv->mii_bus, mii_np);
 238         if (err)
 239                 goto err_free_bus;
 240
 241         return 0;
 242
 243 err_free_bus:
 244         kfree(priv->mii_bus);
 245 err_put_node:
 246         of_node_put(mii_np);
 247         priv->mii_bus = NULL;
 248         return err;
 249 }
 250
 251 void fe_mdio_cleanup(struct fe_priv *priv)
 252 {
 253         if (!priv->mii_bus)
 254                 return;
 255
 256         mdiobus_unregister(priv->mii_bus);
 257         of_node_put(priv->mii_bus->dev.of_node);
 258         kfree(priv->mii_bus);
 259 }