drivers/net/ethernet/atheros/alx/ethtool.c

   1 /*
   2  * Copyright (c) 2013 Johannes Berg <johannes@sipsolutions.net>
   3  *
   4  *  This file is free software: you may copy, redistribute and/or modify it
   5  *  under the terms of the GNU General Public License as published by the
   6  *  Free Software Foundation, either version 2 of the License, or (at your
   7  *  option) any later version.
   8  *
   9  *  This file is distributed in the hope that it will be useful, but
  10  *  WITHOUT ANY WARRANTY; without even the implied warranty of
  11  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  *  General Public License for more details.
  13  *
  14  *  You should have received a copy of the GNU General Public License
  15  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16  *
  17  * This file incorporates work covered by the following copyright and
  18  * permission notice:
  19  *
  20  * Copyright (c) 2012 Qualcomm Atheros, Inc.
  21  *
  22  * Permission to use, copy, modify, and/or distribute this software for any
  23  * purpose with or without fee is hereby granted, provided that the above
  24  * copyright notice and this permission notice appear in all copies.
  25  *
  26  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  27  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  28  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  29  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  30  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  31  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  32  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  33  */
  34
  35 #include <linux/pci.h>
  36 #include <linux/ip.h>
  37 #include <linux/tcp.h>
  38 #include <linux/netdevice.h>
  39 #include <linux/etherdevice.h>
  40 #include <linux/ethtool.h>
  41 #include <linux/mdio.h>
  42 #include <linux/interrupt.h>
  43 #include <asm/byteorder.h>
  44
  45 #include "alx.h"
  46 #include "reg.h"
  47 #include "hw.h"
  48
  49 /* The order of these strings must match the order of the fields in
  50  * struct alx_hw_stats
  51  * See hw.h
  52  */
  53 static const char alx_gstrings_stats[][ETH_GSTRING_LEN] = {
  54         "rx_packets",
  55         "rx_bcast_packets",
  56         "rx_mcast_packets",
  57         "rx_pause_packets",
  58         "rx_ctrl_packets",
  59         "rx_fcs_errors",
  60         "rx_length_errors",
  61         "rx_bytes",
  62         "rx_runt_packets",
  63         "rx_fragments",
  64         "rx_64B_or_less_packets",
  65         "rx_65B_to_127B_packets",
  66         "rx_128B_to_255B_packets",
  67         "rx_256B_to_511B_packets",
  68         "rx_512B_to_1023B_packets",
  69         "rx_1024B_to_1518B_packets",
  70         "rx_1519B_to_mtu_packets",
  71         "rx_oversize_packets",
  72         "rx_rxf_ov_drop_packets",
  73         "rx_rrd_ov_drop_packets",
  74         "rx_align_errors",
  75         "rx_bcast_bytes",
  76         "rx_mcast_bytes",
  77         "rx_address_errors",
  78         "tx_packets",
  79         "tx_bcast_packets",
  80         "tx_mcast_packets",
  81         "tx_pause_packets",
  82         "tx_exc_defer_packets",
  83         "tx_ctrl_packets",
  84         "tx_defer_packets",
  85         "tx_bytes",
  86         "tx_64B_or_less_packets",
  87         "tx_65B_to_127B_packets",
  88         "tx_128B_to_255B_packets",
  89         "tx_256B_to_511B_packets",
  90         "tx_512B_to_1023B_packets",
  91         "tx_1024B_to_1518B_packets",
  92         "tx_1519B_to_mtu_packets",
  93         "tx_single_collision",
  94         "tx_multiple_collisions",
  95         "tx_late_collision",
  96         "tx_abort_collision",
  97         "tx_underrun",
  98         "tx_trd_eop",
  99         "tx_length_errors",
 100         "tx_trunc_packets",
 101         "tx_bcast_bytes",
 102         "tx_mcast_bytes",
 103         "tx_update",
 104 };
 105
 106 #define ALX_NUM_STATS ARRAY_SIZE(alx_gstrings_stats)
 107
 108
 109 static u32 alx_get_supported_speeds(struct alx_hw *hw)
 110 {
 111         u32 supported = SUPPORTED_10baseT_Half |
 112                         SUPPORTED_10baseT_Full |
 113                         SUPPORTED_100baseT_Half |
 114                         SUPPORTED_100baseT_Full;
 115
 116         if (alx_hw_giga(hw))
 117                 supported |= SUPPORTED_1000baseT_Full;
 118
 119         BUILD_BUG_ON(SUPPORTED_10baseT_Half != ADVERTISED_10baseT_Half);
 120         BUILD_BUG_ON(SUPPORTED_10baseT_Full != ADVERTISED_10baseT_Full);
 121         BUILD_BUG_ON(SUPPORTED_100baseT_Half != ADVERTISED_100baseT_Half);
 122         BUILD_BUG_ON(SUPPORTED_100baseT_Full != ADVERTISED_100baseT_Full);
 123         BUILD_BUG_ON(SUPPORTED_1000baseT_Full != ADVERTISED_1000baseT_Full);
 124
 125         return supported;
 126 }
 127
 128 static int alx_get_link_ksettings(struct net_device *netdev,
 129                                   struct ethtool_link_ksettings *cmd)
 130 {
 131         struct alx_priv *alx = netdev_priv(netdev);
 132         struct alx_hw *hw = &alx->hw;
 133         u32 supported, advertising;
 134
 135         supported = SUPPORTED_Autoneg |
 136                           SUPPORTED_TP |
 137                           SUPPORTED_Pause |
 138                           SUPPORTED_Asym_Pause;
 139         if (alx_hw_giga(hw))
 140                 supported |= SUPPORTED_1000baseT_Full;
 141         supported |= alx_get_supported_speeds(hw);
 142
 143         advertising = ADVERTISED_TP;
 144         if (hw->adv_cfg & ADVERTISED_Autoneg)
 145                 advertising |= hw->adv_cfg;
 146
 147         cmd->base.port = PORT_TP;
 148         cmd->base.phy_address = 0;
 149
 150         if (hw->adv_cfg & ADVERTISED_Autoneg)
 151                 cmd->base.autoneg = AUTONEG_ENABLE;
 152         else
 153                 cmd->base.autoneg = AUTONEG_DISABLE;
 154
 155         if (hw->flowctrl & ALX_FC_ANEG && hw->adv_cfg & ADVERTISED_Autoneg) {
 156                 if (hw->flowctrl & ALX_FC_RX) {
 157                         advertising |= ADVERTISED_Pause;
 158
 159                         if (!(hw->flowctrl & ALX_FC_TX))
 160                                 advertising |= ADVERTISED_Asym_Pause;
 161                 } else if (hw->flowctrl & ALX_FC_TX) {
 162                         advertising |= ADVERTISED_Asym_Pause;
 163                 }
 164         }
 165
 166         mutex_lock(&alx->mtx);
 167         cmd->base.speed = hw->link_speed;
 168         cmd->base.duplex = hw->duplex;
 169         mutex_unlock(&alx->mtx);
 170
 171         ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.supported,
 172                                                 supported);
 173         ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.advertising,
 174                                                 advertising);
 175
 176         return 0;
 177 }
 178
 179 static int alx_set_link_ksettings(struct net_device *netdev,
 180                                   const struct ethtool_link_ksettings *cmd)
 181 {
 182         struct alx_priv *alx = netdev_priv(netdev);
 183         struct alx_hw *hw = &alx->hw;
 184         u32 adv_cfg;
 185         u32 advertising;
 186         int ret;
 187
 188         ethtool_convert_link_mode_to_legacy_u32(&advertising,
 189                                                 cmd->link_modes.advertising);
 190
 191         if (cmd->base.autoneg == AUTONEG_ENABLE) {
 192                 if (advertising & ~alx_get_supported_speeds(hw))
 193                         return -EINVAL;
 194                 adv_cfg = advertising | ADVERTISED_Autoneg;
 195         } else {
 196                 adv_cfg = alx_speed_to_ethadv(cmd->base.speed,
 197                                               cmd->base.duplex);
 198
 199                 if (!adv_cfg || adv_cfg == ADVERTISED_1000baseT_Full)
 200                         return -EINVAL;
 201         }
 202
 203         hw->adv_cfg = adv_cfg;
 204
 205         mutex_lock(&alx->mtx);
 206         ret = alx_setup_speed_duplex(hw, adv_cfg, hw->flowctrl);
 207         mutex_unlock(&alx->mtx);
 208
 209         return ret;
 210 }
 211
 212 static void alx_get_pauseparam(struct net_device *netdev,
 213                                struct ethtool_pauseparam *pause)
 214 {
 215         struct alx_priv *alx = netdev_priv(netdev);
 216         struct alx_hw *hw = &alx->hw;
 217
 218         mutex_lock(&alx->mtx);
 219         pause->autoneg = !!(hw->flowctrl & ALX_FC_ANEG &&
 220                             hw->adv_cfg & ADVERTISED_Autoneg);
 221         pause->tx_pause = !!(hw->flowctrl & ALX_FC_TX);
 222         pause->rx_pause = !!(hw->flowctrl & ALX_FC_RX);
 223         mutex_unlock(&alx->mtx);
 224 }
 225
 226
 227 static int alx_set_pauseparam(struct net_device *netdev,
 228                               struct ethtool_pauseparam *pause)
 229 {
 230         struct alx_priv *alx = netdev_priv(netdev);
 231         struct alx_hw *hw = &alx->hw;
 232         int err = 0;
 233         bool reconfig_phy = false;
 234         u8 fc = 0;
 235
 236         if (pause->tx_pause)
 237                 fc |= ALX_FC_TX;
 238         if (pause->rx_pause)
 239                 fc |= ALX_FC_RX;
 240         if (pause->autoneg)
 241                 fc |= ALX_FC_ANEG;
 242
 243         mutex_lock(&alx->mtx);
 244
 245         /* restart auto-neg for auto-mode */
 246         if (hw->adv_cfg & ADVERTISED_Autoneg) {
 247                 if (!((fc ^ hw->flowctrl) & ALX_FC_ANEG))
 248                         reconfig_phy = true;
 249                 if (fc & hw->flowctrl & ALX_FC_ANEG &&
 250                     (fc ^ hw->flowctrl) & (ALX_FC_RX | ALX_FC_TX))
 251                         reconfig_phy = true;
 252         }
 253
 254         if (reconfig_phy) {
 255                 err = alx_setup_speed_duplex(hw, hw->adv_cfg, fc);
 256                 if (err) {
 257                         mutex_unlock(&alx->mtx);
 258                         return err;
 259                 }
 260         }
 261
 262         /* flow control on mac */
 263         if ((fc ^ hw->flowctrl) & (ALX_FC_RX | ALX_FC_TX))
 264                 alx_cfg_mac_flowcontrol(hw, fc);
 265
 266         hw->flowctrl = fc;
 267         mutex_unlock(&alx->mtx);
 268
 269         return 0;
 270 }
 271
 272 static u32 alx_get_msglevel(struct net_device *netdev)
 273 {
 274         struct alx_priv *alx = netdev_priv(netdev);
 275
 276         return alx->msg_enable;
 277 }
 278
 279 static void alx_set_msglevel(struct net_device *netdev, u32 data)
 280 {
 281         struct alx_priv *alx = netdev_priv(netdev);
 282
 283         alx->msg_enable = data;
 284 }
 285
 286 static void alx_get_ethtool_stats(struct net_device *netdev,
 287                                   struct ethtool_stats *estats, u64 *data)
 288 {
 289         struct alx_priv *alx = netdev_priv(netdev);
 290         struct alx_hw *hw = &alx->hw;
 291
 292         spin_lock(&alx->stats_lock);
 293
 294         alx_update_hw_stats(hw);
 295         BUILD_BUG_ON(sizeof(hw->stats) != ALX_NUM_STATS * sizeof(u64));
 296         memcpy(data, &hw->stats, sizeof(hw->stats));
 297
 298         spin_unlock(&alx->stats_lock);
 299 }
 300
 301 static void alx_get_strings(struct net_device *netdev, u32 stringset, u8 *buf)
 302 {
 303         switch (stringset) {
 304         case ETH_SS_STATS:
 305                 memcpy(buf, &alx_gstrings_stats, sizeof(alx_gstrings_stats));
 306                 break;
 307         default:
 308                 WARN_ON(1);
 309                 break;
 310         }
 311 }
 312
 313 static int alx_get_sset_count(struct net_device *netdev, int sset)
 314 {
 315         switch (sset) {
 316         case ETH_SS_STATS:
 317                 return ALX_NUM_STATS;
 318         default:
 319                 return -EINVAL;
 320         }
 321 }
 322
 323 const struct ethtool_ops alx_ethtool_ops = {
 324         .get_pauseparam = alx_get_pauseparam,
 325         .set_pauseparam = alx_set_pauseparam,
 326         .get_msglevel   = alx_get_msglevel,
 327         .set_msglevel   = alx_set_msglevel,
 328         .get_link       = ethtool_op_get_link,
 329         .get_strings    = alx_get_strings,
 330         .get_sset_count = alx_get_sset_count,
 331         .get_ethtool_stats      = alx_get_ethtool_stats,
 332         .get_link_ksettings     = alx_get_link_ksettings,
 333         .set_link_ksettings     = alx_set_link_ksettings,
 334 };