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

   1 /*
   2  *   This program is free software; you can redistribute it and/or modify
   3  *   it under the terms of the GNU General Public License as published by
   4  *   the Free Software Foundation; version 2 of the License
   5  *
   6  *   This program is distributed in the hope that it will be useful,
   7  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
   8  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   9  *   GNU General Public License for more details.
  10  *
  11  *   You should have received a copy of the GNU General Public License
  12  *   along with this program; if not, write to the Free Software
  13  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
  14  *
  15  *   Copyright (C) 2009-2013 Michael Lee <igvtee@gmail.com>
  16  */
  17
  18 #include "ralink_soc_eth.h"
  19
  20 static const char fe_gdma_str[][ETH_GSTRING_LEN] = {
  21 #define _FE(x...)       # x,
  22 FE_STAT_REG_DECLARE
  23 #undef _FE
  24 };
  25
  26 static int fe_get_settings(struct net_device *dev,
  27                 struct ethtool_cmd *cmd)
  28 {
  29         struct fe_priv *priv = netdev_priv(dev);
  30         int err;
  31
  32         if (!priv->phy_dev)
  33                 goto out_gset;
  34
  35         if (priv->phy_flags == FE_PHY_FLAG_ATTACH) {
  36                 err = phy_read_status(priv->phy_dev);
  37                 if (err)
  38                         goto out_gset;
  39         }
  40
  41         return phy_ethtool_gset(priv->phy_dev, cmd);
  42
  43 out_gset:
  44         return -ENODEV;
  45 }
  46
  47 static int fe_set_settings(struct net_device *dev,
  48                 struct ethtool_cmd *cmd)
  49 {
  50         struct fe_priv *priv = netdev_priv(dev);
  51
  52         if (!priv->phy_dev)
  53                 goto out_sset;
  54
  55         if (cmd->phy_address != priv->phy_dev->addr) {
  56                 if (priv->phy->phy_node[cmd->phy_address]) {
  57                         priv->phy_dev = priv->phy->phy[cmd->phy_address];
  58                         priv->phy_flags = FE_PHY_FLAG_PORT;
  59                 } else if (priv->mii_bus &&
  60                                 priv->mii_bus->phy_map[cmd->phy_address]) {
  61                         priv->phy_dev = priv->mii_bus->phy_map[cmd->phy_address];
  62                         priv->phy_flags = FE_PHY_FLAG_ATTACH;
  63                 } else
  64                         goto out_sset;
  65         }
  66
  67         return phy_ethtool_sset(priv->phy_dev, cmd);
  68
  69 out_sset:
  70         return -ENODEV;
  71 }
  72
  73 static void fe_get_drvinfo (struct net_device *dev,
  74                 struct ethtool_drvinfo *info)
  75 {
  76         struct fe_priv *priv = netdev_priv(dev);
  77         struct fe_soc_data *soc = priv->soc;
  78
  79         strlcpy(info->driver, priv->device->driver->name, sizeof(info->driver));
  80         strlcpy(info->version, FE_DRV_VERSION, sizeof(info->version));
  81         strlcpy(info->bus_info, dev_name(priv->device), sizeof(info->bus_info));
  82
  83         if (soc->reg_table[FE_REG_FE_COUNTER_BASE])
  84                 info->n_stats = ARRAY_SIZE(fe_gdma_str);
  85 }
  86
  87 static u32 fe_get_msglevel(struct net_device *dev)
  88 {
  89         struct fe_priv *priv = netdev_priv(dev);
  90
  91         return priv->msg_enable;
  92 }
  93
  94 static void fe_set_msglevel(struct net_device *dev, u32 value)
  95 {
  96         struct fe_priv *priv = netdev_priv(dev);
  97
  98         priv->msg_enable = value;
  99 }
 100
 101 static int fe_nway_reset(struct net_device *dev)
 102 {
 103         struct fe_priv *priv = netdev_priv(dev);
 104
 105         if (!priv->phy_dev)
 106                 goto out_nway_reset;
 107
 108         return genphy_restart_aneg(priv->phy_dev);
 109
 110 out_nway_reset:
 111         return -EOPNOTSUPP;
 112 }
 113
 114 static u32 fe_get_link(struct net_device *dev)
 115 {
 116         struct fe_priv *priv = netdev_priv(dev);
 117         int err;
 118
 119         if (!priv->phy_dev)
 120                 goto out_get_link;
 121
 122         if (priv->phy_flags == FE_PHY_FLAG_ATTACH) {
 123                 err = genphy_update_link(priv->phy_dev);
 124                 if (err)
 125                         goto out_get_link;
 126         }
 127
 128         return priv->phy_dev->link;
 129
 130 out_get_link:
 131         return ethtool_op_get_link(dev);
 132 }
 133
 134 static int fe_set_ringparam(struct net_device *dev,
 135                 struct ethtool_ringparam *ring)
 136 {
 137         struct fe_priv *priv = netdev_priv(dev);
 138
 139         if ((ring->tx_pending < 2) ||
 140                         (ring->rx_pending < 2) ||
 141                         (ring->rx_pending > MAX_DMA_DESC) ||
 142                         (ring->tx_pending > MAX_DMA_DESC))
 143                 return -EINVAL;
 144
 145         dev->netdev_ops->ndo_stop(dev);
 146
 147         priv->tx_ring_size = BIT(fls(ring->tx_pending) - 1);
 148         priv->rx_ring_size = BIT(fls(ring->rx_pending) - 1);
 149
 150         dev->netdev_ops->ndo_open(dev);
 151
 152         return 0;
 153 }
 154
 155 static void fe_get_ringparam(struct net_device *dev,
 156                 struct ethtool_ringparam *ring)
 157 {
 158         struct fe_priv *priv = netdev_priv(dev);
 159
 160         ring->rx_max_pending = MAX_DMA_DESC;
 161         ring->tx_max_pending = MAX_DMA_DESC;
 162         ring->rx_pending = priv->rx_ring_size;
 163         ring->tx_pending = priv->tx_ring_size;
 164 }
 165
 166 static void fe_get_strings(struct net_device *dev, u32 stringset, u8 *data)
 167 {
 168         switch (stringset) {
 169         case ETH_SS_STATS:
 170                 memcpy(data, *fe_gdma_str, sizeof(fe_gdma_str));
 171                 break;
 172         }
 173 }
 174
 175 static int fe_get_sset_count(struct net_device *dev, int sset)
 176 {
 177         switch (sset) {
 178         case ETH_SS_STATS:
 179                 return ARRAY_SIZE(fe_gdma_str);
 180         default:
 181                 return -EOPNOTSUPP;
 182         }
 183 }
 184
 185 static void fe_get_ethtool_stats(struct net_device *dev,
 186                 struct ethtool_stats *stats, u64 *data)
 187 {
 188         struct fe_priv *priv = netdev_priv(dev);
 189         struct fe_hw_stats *hwstats = priv->hw_stats;
 190         u64 *data_src, *data_dst;
 191         unsigned int start;
 192         int i;
 193
 194         if (netif_running(dev) && netif_device_present(dev)) {
 195                 if (spin_trylock(&hwstats->stats_lock)) {
 196                         fe_stats_update(priv);
 197                         spin_unlock(&hwstats->stats_lock);
 198                 }
 199         }
 200
 201         do {
 202                 data_src = &hwstats->tx_bytes;
 203                 data_dst = data;
 204                 start = u64_stats_fetch_begin_irq(&hwstats->syncp);
 205
 206                 for (i = 0; i < ARRAY_SIZE(fe_gdma_str); i++)
 207                         *data_dst++ = *data_src++;
 208
 209         } while (u64_stats_fetch_retry_irq(&hwstats->syncp, start));
 210 }
 211
 212 static struct ethtool_ops fe_ethtool_ops = {
 213         .get_settings           = fe_get_settings,
 214         .set_settings           = fe_set_settings,
 215         .get_drvinfo            = fe_get_drvinfo,
 216         .get_msglevel           = fe_get_msglevel,
 217         .set_msglevel           = fe_set_msglevel,
 218         .nway_reset             = fe_nway_reset,
 219         .get_link               = fe_get_link,
 220         .set_ringparam          = fe_set_ringparam,
 221         .get_ringparam          = fe_get_ringparam,
 222 };
 223
 224 void fe_set_ethtool_ops(struct net_device *netdev)
 225 {
 226         struct fe_priv *priv = netdev_priv(netdev);
 227         struct fe_soc_data *soc = priv->soc;
 228
 229         if (soc->reg_table[FE_REG_FE_COUNTER_BASE]) {
 230                 fe_ethtool_ops.get_strings = fe_get_strings;
 231                 fe_ethtool_ops.get_sset_count = fe_get_sset_count;
 232                 fe_ethtool_ops.get_ethtool_stats = fe_get_ethtool_stats;
 233         }
 234
 235         netdev->ethtool_ops = &fe_ethtool_ops;
 236 }