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 }; 335