1 // SPDX-License-Identifier: GPL-2.0 2 /* Copyright (c) 2018, Intel Corporation. */ 3 4 /* ethtool support for ice */ 5 6 #include "ice.h" 7 8 struct ice_stats { 9 char stat_string[ETH_GSTRING_LEN]; 10 int sizeof_stat; 11 int stat_offset; 12 }; 13 14 #define ICE_STAT(_type, _name, _stat) { \ 15 .stat_string = _name, \ 16 .sizeof_stat = FIELD_SIZEOF(_type, _stat), \ 17 .stat_offset = offsetof(_type, _stat) \ 18 } 19 20 #define ICE_VSI_STAT(_name, _stat) \ 21 ICE_STAT(struct ice_vsi, _name, _stat) 22 #define ICE_PF_STAT(_name, _stat) \ 23 ICE_STAT(struct ice_pf, _name, _stat) 24 25 static int ice_q_stats_len(struct net_device *netdev) 26 { 27 struct ice_netdev_priv *np = netdev_priv(netdev); 28 29 return ((np->vsi->alloc_txq + np->vsi->alloc_rxq) * 30 (sizeof(struct ice_q_stats) / sizeof(u64))); 31 } 32 33 #define ICE_PF_STATS_LEN ARRAY_SIZE(ice_gstrings_pf_stats) 34 #define ICE_VSI_STATS_LEN ARRAY_SIZE(ice_gstrings_vsi_stats) 35 36 #define ICE_ALL_STATS_LEN(n) (ICE_PF_STATS_LEN + ICE_VSI_STATS_LEN + \ 37 ice_q_stats_len(n)) 38 39 static const struct ice_stats ice_gstrings_vsi_stats[] = { 40 ICE_VSI_STAT("tx_unicast", eth_stats.tx_unicast), 41 ICE_VSI_STAT("rx_unicast", eth_stats.rx_unicast), 42 ICE_VSI_STAT("tx_multicast", eth_stats.tx_multicast), 43 ICE_VSI_STAT("rx_multicast", eth_stats.rx_multicast), 44 ICE_VSI_STAT("tx_broadcast", eth_stats.tx_broadcast), 45 ICE_VSI_STAT("rx_broadcast", eth_stats.rx_broadcast), 46 ICE_VSI_STAT("tx_bytes", eth_stats.tx_bytes), 47 ICE_VSI_STAT("rx_bytes", eth_stats.rx_bytes), 48 ICE_VSI_STAT("rx_discards", eth_stats.rx_discards), 49 ICE_VSI_STAT("tx_errors", eth_stats.tx_errors), 50 ICE_VSI_STAT("tx_linearize", tx_linearize), 51 ICE_VSI_STAT("rx_unknown_protocol", eth_stats.rx_unknown_protocol), 52 ICE_VSI_STAT("rx_alloc_fail", rx_buf_failed), 53 ICE_VSI_STAT("rx_pg_alloc_fail", rx_page_failed), 54 }; 55 56 /* These PF_STATs might look like duplicates of some NETDEV_STATs, 57 * but they aren't. This device is capable of supporting multiple 58 * VSIs/netdevs on a single PF. The NETDEV_STATs are for individual 59 * netdevs whereas the PF_STATs are for the physical function that's 60 * hosting these netdevs. 61 * 62 * The PF_STATs are appended to the netdev stats only when ethtool -S 63 * is queried on the base PF netdev. 64 */ 65 static struct ice_stats ice_gstrings_pf_stats[] = { 66 ICE_PF_STAT("tx_bytes", stats.eth.tx_bytes), 67 ICE_PF_STAT("rx_bytes", stats.eth.rx_bytes), 68 ICE_PF_STAT("tx_unicast", stats.eth.tx_unicast), 69 ICE_PF_STAT("rx_unicast", stats.eth.rx_unicast), 70 ICE_PF_STAT("tx_multicast", stats.eth.tx_multicast), 71 ICE_PF_STAT("rx_multicast", stats.eth.rx_multicast), 72 ICE_PF_STAT("tx_broadcast", stats.eth.tx_broadcast), 73 ICE_PF_STAT("rx_broadcast", stats.eth.rx_broadcast), 74 ICE_PF_STAT("tx_errors", stats.eth.tx_errors), 75 ICE_PF_STAT("tx_size_64", stats.tx_size_64), 76 ICE_PF_STAT("rx_size_64", stats.rx_size_64), 77 ICE_PF_STAT("tx_size_127", stats.tx_size_127), 78 ICE_PF_STAT("rx_size_127", stats.rx_size_127), 79 ICE_PF_STAT("tx_size_255", stats.tx_size_255), 80 ICE_PF_STAT("rx_size_255", stats.rx_size_255), 81 ICE_PF_STAT("tx_size_511", stats.tx_size_511), 82 ICE_PF_STAT("rx_size_511", stats.rx_size_511), 83 ICE_PF_STAT("tx_size_1023", stats.tx_size_1023), 84 ICE_PF_STAT("rx_size_1023", stats.rx_size_1023), 85 ICE_PF_STAT("tx_size_1522", stats.tx_size_1522), 86 ICE_PF_STAT("rx_size_1522", stats.rx_size_1522), 87 ICE_PF_STAT("tx_size_big", stats.tx_size_big), 88 ICE_PF_STAT("rx_size_big", stats.rx_size_big), 89 ICE_PF_STAT("link_xon_tx", stats.link_xon_tx), 90 ICE_PF_STAT("link_xon_rx", stats.link_xon_rx), 91 ICE_PF_STAT("link_xoff_tx", stats.link_xoff_tx), 92 ICE_PF_STAT("link_xoff_rx", stats.link_xoff_rx), 93 ICE_PF_STAT("tx_dropped_link_down", stats.tx_dropped_link_down), 94 ICE_PF_STAT("rx_undersize", stats.rx_undersize), 95 ICE_PF_STAT("rx_fragments", stats.rx_fragments), 96 ICE_PF_STAT("rx_oversize", stats.rx_oversize), 97 ICE_PF_STAT("rx_jabber", stats.rx_jabber), 98 ICE_PF_STAT("rx_csum_bad", hw_csum_rx_error), 99 ICE_PF_STAT("rx_length_errors", stats.rx_len_errors), 100 ICE_PF_STAT("rx_dropped", stats.eth.rx_discards), 101 ICE_PF_STAT("rx_crc_errors", stats.crc_errors), 102 ICE_PF_STAT("illegal_bytes", stats.illegal_bytes), 103 ICE_PF_STAT("mac_local_faults", stats.mac_local_faults), 104 ICE_PF_STAT("mac_remote_faults", stats.mac_remote_faults), 105 }; 106 107 static u32 ice_regs_dump_list[] = { 108 PFGEN_STATE, 109 PRTGEN_STATUS, 110 QRX_CTRL(0), 111 QINT_TQCTL(0), 112 QINT_RQCTL(0), 113 PFINT_OICR_ENA, 114 QRX_ITR(0), 115 }; 116 117 /** 118 * ice_nvm_version_str - format the NVM version strings 119 * @hw: ptr to the hardware info 120 */ 121 static char *ice_nvm_version_str(struct ice_hw *hw) 122 { 123 static char buf[ICE_ETHTOOL_FWVER_LEN]; 124 u8 ver, patch; 125 u32 full_ver; 126 u16 build; 127 128 full_ver = hw->nvm.oem_ver; 129 ver = (u8)((full_ver & ICE_OEM_VER_MASK) >> ICE_OEM_VER_SHIFT); 130 build = (u16)((full_ver & ICE_OEM_VER_BUILD_MASK) >> 131 ICE_OEM_VER_BUILD_SHIFT); 132 patch = (u8)(full_ver & ICE_OEM_VER_PATCH_MASK); 133 134 snprintf(buf, sizeof(buf), "%x.%02x 0x%x %d.%d.%d", 135 (hw->nvm.ver & ICE_NVM_VER_HI_MASK) >> ICE_NVM_VER_HI_SHIFT, 136 (hw->nvm.ver & ICE_NVM_VER_LO_MASK) >> ICE_NVM_VER_LO_SHIFT, 137 hw->nvm.eetrack, ver, build, patch); 138 139 return buf; 140 } 141 142 static void 143 ice_get_drvinfo(struct net_device *netdev, struct ethtool_drvinfo *drvinfo) 144 { 145 struct ice_netdev_priv *np = netdev_priv(netdev); 146 struct ice_vsi *vsi = np->vsi; 147 struct ice_pf *pf = vsi->back; 148 149 strlcpy(drvinfo->driver, KBUILD_MODNAME, sizeof(drvinfo->driver)); 150 strlcpy(drvinfo->version, ice_drv_ver, sizeof(drvinfo->version)); 151 strlcpy(drvinfo->fw_version, ice_nvm_version_str(&pf->hw), 152 sizeof(drvinfo->fw_version)); 153 strlcpy(drvinfo->bus_info, pci_name(pf->pdev), 154 sizeof(drvinfo->bus_info)); 155 } 156 157 static int ice_get_regs_len(struct net_device __always_unused *netdev) 158 { 159 return sizeof(ice_regs_dump_list); 160 } 161 162 static void 163 ice_get_regs(struct net_device *netdev, struct ethtool_regs *regs, void *p) 164 { 165 struct ice_netdev_priv *np = netdev_priv(netdev); 166 struct ice_pf *pf = np->vsi->back; 167 struct ice_hw *hw = &pf->hw; 168 u32 *regs_buf = (u32 *)p; 169 int i; 170 171 regs->version = 1; 172 173 for (i = 0; i < ARRAY_SIZE(ice_regs_dump_list); ++i) 174 regs_buf[i] = rd32(hw, ice_regs_dump_list[i]); 175 } 176 177 static u32 ice_get_msglevel(struct net_device *netdev) 178 { 179 struct ice_netdev_priv *np = netdev_priv(netdev); 180 struct ice_pf *pf = np->vsi->back; 181 182 #ifndef CONFIG_DYNAMIC_DEBUG 183 if (pf->hw.debug_mask) 184 netdev_info(netdev, "hw debug_mask: 0x%llX\n", 185 pf->hw.debug_mask); 186 #endif /* !CONFIG_DYNAMIC_DEBUG */ 187 188 return pf->msg_enable; 189 } 190 191 static void ice_set_msglevel(struct net_device *netdev, u32 data) 192 { 193 struct ice_netdev_priv *np = netdev_priv(netdev); 194 struct ice_pf *pf = np->vsi->back; 195 196 #ifndef CONFIG_DYNAMIC_DEBUG 197 if (ICE_DBG_USER & data) 198 pf->hw.debug_mask = data; 199 else 200 pf->msg_enable = data; 201 #else 202 pf->msg_enable = data; 203 #endif /* !CONFIG_DYNAMIC_DEBUG */ 204 } 205 206 static void ice_get_strings(struct net_device *netdev, u32 stringset, u8 *data) 207 { 208 struct ice_netdev_priv *np = netdev_priv(netdev); 209 struct ice_vsi *vsi = np->vsi; 210 char *p = (char *)data; 211 unsigned int i; 212 213 switch (stringset) { 214 case ETH_SS_STATS: 215 for (i = 0; i < ICE_VSI_STATS_LEN; i++) { 216 snprintf(p, ETH_GSTRING_LEN, "%s", 217 ice_gstrings_vsi_stats[i].stat_string); 218 p += ETH_GSTRING_LEN; 219 } 220 221 ice_for_each_alloc_txq(vsi, i) { 222 snprintf(p, ETH_GSTRING_LEN, 223 "tx-queue-%u.tx_packets", i); 224 p += ETH_GSTRING_LEN; 225 snprintf(p, ETH_GSTRING_LEN, "tx-queue-%u.tx_bytes", i); 226 p += ETH_GSTRING_LEN; 227 } 228 229 ice_for_each_alloc_rxq(vsi, i) { 230 snprintf(p, ETH_GSTRING_LEN, 231 "rx-queue-%u.rx_packets", i); 232 p += ETH_GSTRING_LEN; 233 snprintf(p, ETH_GSTRING_LEN, "rx-queue-%u.rx_bytes", i); 234 p += ETH_GSTRING_LEN; 235 } 236 237 if (vsi->type != ICE_VSI_PF) 238 return; 239 240 for (i = 0; i < ICE_PF_STATS_LEN; i++) { 241 snprintf(p, ETH_GSTRING_LEN, "port.%s", 242 ice_gstrings_pf_stats[i].stat_string); 243 p += ETH_GSTRING_LEN; 244 } 245 246 break; 247 default: 248 break; 249 } 250 } 251 252 static int ice_get_sset_count(struct net_device *netdev, int sset) 253 { 254 switch (sset) { 255 case ETH_SS_STATS: 256 /* The number (and order) of strings reported *must* remain 257 * constant for a given netdevice. This function must not 258 * report a different number based on run time parameters 259 * (such as the number of queues in use, or the setting of 260 * a private ethtool flag). This is due to the nature of the 261 * ethtool stats API. 262 * 263 * User space programs such as ethtool must make 3 separate 264 * ioctl requests, one for size, one for the strings, and 265 * finally one for the stats. Since these cross into 266 * user space, changes to the number or size could result in 267 * undefined memory access or incorrect string<->value 268 * correlations for statistics. 269 * 270 * Even if it appears to be safe, changes to the size or 271 * order of strings will suffer from race conditions and are 272 * not safe. 273 */ 274 return ICE_ALL_STATS_LEN(netdev); 275 default: 276 return -EOPNOTSUPP; 277 } 278 } 279 280 static void 281 ice_get_ethtool_stats(struct net_device *netdev, 282 struct ethtool_stats __always_unused *stats, u64 *data) 283 { 284 struct ice_netdev_priv *np = netdev_priv(netdev); 285 struct ice_vsi *vsi = np->vsi; 286 struct ice_pf *pf = vsi->back; 287 struct ice_ring *ring; 288 unsigned int j = 0; 289 int i = 0; 290 char *p; 291 292 for (j = 0; j < ICE_VSI_STATS_LEN; j++) { 293 p = (char *)vsi + ice_gstrings_vsi_stats[j].stat_offset; 294 data[i++] = (ice_gstrings_vsi_stats[j].sizeof_stat == 295 sizeof(u64)) ? *(u64 *)p : *(u32 *)p; 296 } 297 298 /* populate per queue stats */ 299 rcu_read_lock(); 300 301 ice_for_each_alloc_txq(vsi, j) { 302 ring = READ_ONCE(vsi->tx_rings[j]); 303 if (ring) { 304 data[i++] = ring->stats.pkts; 305 data[i++] = ring->stats.bytes; 306 } else { 307 data[i++] = 0; 308 data[i++] = 0; 309 } 310 } 311 312 ice_for_each_alloc_rxq(vsi, j) { 313 ring = READ_ONCE(vsi->rx_rings[j]); 314 if (ring) { 315 data[i++] = ring->stats.pkts; 316 data[i++] = ring->stats.bytes; 317 } else { 318 data[i++] = 0; 319 data[i++] = 0; 320 } 321 } 322 323 rcu_read_unlock(); 324 325 if (vsi->type != ICE_VSI_PF) 326 return; 327 328 for (j = 0; j < ICE_PF_STATS_LEN; j++) { 329 p = (char *)pf + ice_gstrings_pf_stats[j].stat_offset; 330 data[i++] = (ice_gstrings_pf_stats[j].sizeof_stat == 331 sizeof(u64)) ? *(u64 *)p : *(u32 *)p; 332 } 333 } 334 335 /** 336 * ice_phy_type_to_ethtool - convert the phy_types to ethtool link modes 337 * @netdev: network interface device structure 338 * @ks: ethtool link ksettings struct to fill out 339 */ 340 static void ice_phy_type_to_ethtool(struct net_device *netdev, 341 struct ethtool_link_ksettings *ks) 342 { 343 struct ice_netdev_priv *np = netdev_priv(netdev); 344 struct ice_link_status *hw_link_info; 345 struct ice_vsi *vsi = np->vsi; 346 u64 phy_types_low; 347 348 hw_link_info = &vsi->port_info->phy.link_info; 349 phy_types_low = vsi->port_info->phy.phy_type_low; 350 351 ethtool_link_ksettings_zero_link_mode(ks, supported); 352 ethtool_link_ksettings_zero_link_mode(ks, advertising); 353 354 if (phy_types_low & ICE_PHY_TYPE_LOW_100BASE_TX || 355 phy_types_low & ICE_PHY_TYPE_LOW_100M_SGMII) { 356 ethtool_link_ksettings_add_link_mode(ks, supported, 357 100baseT_Full); 358 if (hw_link_info->req_speeds & ICE_AQ_LINK_SPEED_100MB) 359 ethtool_link_ksettings_add_link_mode(ks, advertising, 360 100baseT_Full); 361 } 362 if (phy_types_low & ICE_PHY_TYPE_LOW_1000BASE_T || 363 phy_types_low & ICE_PHY_TYPE_LOW_1G_SGMII) { 364 ethtool_link_ksettings_add_link_mode(ks, supported, 365 1000baseT_Full); 366 if (hw_link_info->req_speeds & ICE_AQ_LINK_SPEED_1000MB) 367 ethtool_link_ksettings_add_link_mode(ks, advertising, 368 1000baseT_Full); 369 } 370 if (phy_types_low & ICE_PHY_TYPE_LOW_1000BASE_KX) { 371 ethtool_link_ksettings_add_link_mode(ks, supported, 372 1000baseKX_Full); 373 if (hw_link_info->req_speeds & ICE_AQ_LINK_SPEED_1000MB) 374 ethtool_link_ksettings_add_link_mode(ks, advertising, 375 1000baseKX_Full); 376 } 377 if (phy_types_low & ICE_PHY_TYPE_LOW_1000BASE_SX || 378 phy_types_low & ICE_PHY_TYPE_LOW_1000BASE_LX) { 379 ethtool_link_ksettings_add_link_mode(ks, supported, 380 1000baseX_Full); 381 if (hw_link_info->req_speeds & ICE_AQ_LINK_SPEED_1000MB) 382 ethtool_link_ksettings_add_link_mode(ks, advertising, 383 1000baseX_Full); 384 } 385 if (phy_types_low & ICE_PHY_TYPE_LOW_2500BASE_T) { 386 ethtool_link_ksettings_add_link_mode(ks, supported, 387 2500baseT_Full); 388 if (hw_link_info->req_speeds & ICE_AQ_LINK_SPEED_2500MB) 389 ethtool_link_ksettings_add_link_mode(ks, advertising, 390 2500baseT_Full); 391 } 392 if (phy_types_low & ICE_PHY_TYPE_LOW_2500BASE_X || 393 phy_types_low & ICE_PHY_TYPE_LOW_2500BASE_KX) { 394 ethtool_link_ksettings_add_link_mode(ks, supported, 395 2500baseX_Full); 396 if (hw_link_info->req_speeds & ICE_AQ_LINK_SPEED_2500MB) 397 ethtool_link_ksettings_add_link_mode(ks, advertising, 398 2500baseX_Full); 399 } 400 if (phy_types_low & ICE_PHY_TYPE_LOW_5GBASE_T || 401 phy_types_low & ICE_PHY_TYPE_LOW_5GBASE_KR) { 402 ethtool_link_ksettings_add_link_mode(ks, supported, 403 5000baseT_Full); 404 if (hw_link_info->req_speeds & ICE_AQ_LINK_SPEED_5GB) 405 ethtool_link_ksettings_add_link_mode(ks, advertising, 406 5000baseT_Full); 407 } 408 if (phy_types_low & ICE_PHY_TYPE_LOW_10GBASE_T || 409 phy_types_low & ICE_PHY_TYPE_LOW_10G_SFI_DA || 410 phy_types_low & ICE_PHY_TYPE_LOW_10G_SFI_AOC_ACC || 411 phy_types_low & ICE_PHY_TYPE_LOW_10G_SFI_C2C) { 412 ethtool_link_ksettings_add_link_mode(ks, supported, 413 10000baseT_Full); 414 if (hw_link_info->req_speeds & ICE_AQ_LINK_SPEED_10GB) 415 ethtool_link_ksettings_add_link_mode(ks, advertising, 416 10000baseT_Full); 417 } 418 if (phy_types_low & ICE_PHY_TYPE_LOW_10GBASE_KR_CR1) { 419 ethtool_link_ksettings_add_link_mode(ks, supported, 420 10000baseKR_Full); 421 if (hw_link_info->req_speeds & ICE_AQ_LINK_SPEED_10GB) 422 ethtool_link_ksettings_add_link_mode(ks, advertising, 423 10000baseKR_Full); 424 } 425 if (phy_types_low & ICE_PHY_TYPE_LOW_10GBASE_SR) { 426 ethtool_link_ksettings_add_link_mode(ks, supported, 427 10000baseSR_Full); 428 if (hw_link_info->req_speeds & ICE_AQ_LINK_SPEED_10GB) 429 ethtool_link_ksettings_add_link_mode(ks, advertising, 430 10000baseSR_Full); 431 } 432 if (phy_types_low & ICE_PHY_TYPE_LOW_10GBASE_LR) { 433 ethtool_link_ksettings_add_link_mode(ks, supported, 434 10000baseLR_Full); 435 if (hw_link_info->req_speeds & ICE_AQ_LINK_SPEED_10GB) 436 ethtool_link_ksettings_add_link_mode(ks, advertising, 437 10000baseLR_Full); 438 } 439 if (phy_types_low & ICE_PHY_TYPE_LOW_25GBASE_T || 440 phy_types_low & ICE_PHY_TYPE_LOW_25GBASE_CR || 441 phy_types_low & ICE_PHY_TYPE_LOW_25GBASE_CR_S || 442 phy_types_low & ICE_PHY_TYPE_LOW_25GBASE_CR1 || 443 phy_types_low & ICE_PHY_TYPE_LOW_25G_AUI_AOC_ACC || 444 phy_types_low & ICE_PHY_TYPE_LOW_25G_AUI_C2C) { 445 ethtool_link_ksettings_add_link_mode(ks, supported, 446 25000baseCR_Full); 447 if (hw_link_info->req_speeds & ICE_AQ_LINK_SPEED_25GB) 448 ethtool_link_ksettings_add_link_mode(ks, advertising, 449 25000baseCR_Full); 450 } 451 if (phy_types_low & ICE_PHY_TYPE_LOW_25GBASE_SR || 452 phy_types_low & ICE_PHY_TYPE_LOW_25GBASE_LR) { 453 ethtool_link_ksettings_add_link_mode(ks, supported, 454 25000baseSR_Full); 455 if (hw_link_info->req_speeds & ICE_AQ_LINK_SPEED_25GB) 456 ethtool_link_ksettings_add_link_mode(ks, advertising, 457 25000baseSR_Full); 458 } 459 if (phy_types_low & ICE_PHY_TYPE_LOW_25GBASE_KR || 460 phy_types_low & ICE_PHY_TYPE_LOW_25GBASE_KR_S || 461 phy_types_low & ICE_PHY_TYPE_LOW_25GBASE_KR1) { 462 ethtool_link_ksettings_add_link_mode(ks, supported, 463 25000baseKR_Full); 464 if (hw_link_info->req_speeds & ICE_AQ_LINK_SPEED_25GB) 465 ethtool_link_ksettings_add_link_mode(ks, advertising, 466 25000baseKR_Full); 467 } 468 if (phy_types_low & ICE_PHY_TYPE_LOW_40GBASE_KR4) { 469 ethtool_link_ksettings_add_link_mode(ks, supported, 470 40000baseKR4_Full); 471 if (hw_link_info->req_speeds & ICE_AQ_LINK_SPEED_40GB) 472 ethtool_link_ksettings_add_link_mode(ks, advertising, 473 40000baseKR4_Full); 474 } 475 if (phy_types_low & ICE_PHY_TYPE_LOW_40GBASE_CR4 || 476 phy_types_low & ICE_PHY_TYPE_LOW_40G_XLAUI_AOC_ACC || 477 phy_types_low & ICE_PHY_TYPE_LOW_40G_XLAUI) { 478 ethtool_link_ksettings_add_link_mode(ks, supported, 479 40000baseCR4_Full); 480 if (hw_link_info->req_speeds & ICE_AQ_LINK_SPEED_40GB) 481 ethtool_link_ksettings_add_link_mode(ks, advertising, 482 40000baseCR4_Full); 483 } 484 if (phy_types_low & ICE_PHY_TYPE_LOW_40GBASE_SR4) { 485 ethtool_link_ksettings_add_link_mode(ks, supported, 486 40000baseSR4_Full); 487 if (hw_link_info->req_speeds & ICE_AQ_LINK_SPEED_40GB) 488 ethtool_link_ksettings_add_link_mode(ks, advertising, 489 40000baseSR4_Full); 490 } 491 if (phy_types_low & ICE_PHY_TYPE_LOW_40GBASE_LR4) { 492 ethtool_link_ksettings_add_link_mode(ks, supported, 493 40000baseLR4_Full); 494 if (hw_link_info->req_speeds & ICE_AQ_LINK_SPEED_40GB) 495 ethtool_link_ksettings_add_link_mode(ks, advertising, 496 40000baseLR4_Full); 497 } 498 499 /* Autoneg PHY types */ 500 if (phy_types_low & ICE_PHY_TYPE_LOW_100BASE_TX || 501 phy_types_low & ICE_PHY_TYPE_LOW_1000BASE_T || 502 phy_types_low & ICE_PHY_TYPE_LOW_1000BASE_KX || 503 phy_types_low & ICE_PHY_TYPE_LOW_2500BASE_T || 504 phy_types_low & ICE_PHY_TYPE_LOW_2500BASE_KX || 505 phy_types_low & ICE_PHY_TYPE_LOW_5GBASE_T || 506 phy_types_low & ICE_PHY_TYPE_LOW_5GBASE_KR || 507 phy_types_low & ICE_PHY_TYPE_LOW_10GBASE_T || 508 phy_types_low & ICE_PHY_TYPE_LOW_10GBASE_KR_CR1 || 509 phy_types_low & ICE_PHY_TYPE_LOW_25GBASE_T || 510 phy_types_low & ICE_PHY_TYPE_LOW_25GBASE_CR || 511 phy_types_low & ICE_PHY_TYPE_LOW_25GBASE_CR_S || 512 phy_types_low & ICE_PHY_TYPE_LOW_25GBASE_CR1 || 513 phy_types_low & ICE_PHY_TYPE_LOW_25GBASE_KR || 514 phy_types_low & ICE_PHY_TYPE_LOW_25GBASE_KR_S || 515 phy_types_low & ICE_PHY_TYPE_LOW_25GBASE_KR1 || 516 phy_types_low & ICE_PHY_TYPE_LOW_40GBASE_CR4 || 517 phy_types_low & ICE_PHY_TYPE_LOW_40GBASE_KR4) { 518 ethtool_link_ksettings_add_link_mode(ks, supported, 519 Autoneg); 520 ethtool_link_ksettings_add_link_mode(ks, advertising, 521 Autoneg); 522 } 523 } 524 525 #define TEST_SET_BITS_TIMEOUT 50 526 #define TEST_SET_BITS_SLEEP_MAX 2000 527 #define TEST_SET_BITS_SLEEP_MIN 1000 528 529 /** 530 * ice_get_settings_link_up - Get Link settings for when link is up 531 * @ks: ethtool ksettings to fill in 532 * @netdev: network interface device structure 533 */ 534 static void ice_get_settings_link_up(struct ethtool_link_ksettings *ks, 535 struct net_device *netdev) 536 { 537 struct ice_netdev_priv *np = netdev_priv(netdev); 538 struct ethtool_link_ksettings cap_ksettings; 539 struct ice_link_status *link_info; 540 struct ice_vsi *vsi = np->vsi; 541 bool unrecog_phy_low = false; 542 543 link_info = &vsi->port_info->phy.link_info; 544 545 /* Initialize supported and advertised settings based on phy settings */ 546 switch (link_info->phy_type_low) { 547 case ICE_PHY_TYPE_LOW_100BASE_TX: 548 ethtool_link_ksettings_add_link_mode(ks, supported, Autoneg); 549 ethtool_link_ksettings_add_link_mode(ks, supported, 550 100baseT_Full); 551 ethtool_link_ksettings_add_link_mode(ks, advertising, Autoneg); 552 ethtool_link_ksettings_add_link_mode(ks, advertising, 553 100baseT_Full); 554 break; 555 case ICE_PHY_TYPE_LOW_100M_SGMII: 556 ethtool_link_ksettings_add_link_mode(ks, supported, 557 100baseT_Full); 558 break; 559 case ICE_PHY_TYPE_LOW_1000BASE_T: 560 ethtool_link_ksettings_add_link_mode(ks, supported, Autoneg); 561 ethtool_link_ksettings_add_link_mode(ks, supported, 562 1000baseT_Full); 563 ethtool_link_ksettings_add_link_mode(ks, advertising, Autoneg); 564 ethtool_link_ksettings_add_link_mode(ks, advertising, 565 1000baseT_Full); 566 break; 567 case ICE_PHY_TYPE_LOW_1G_SGMII: 568 ethtool_link_ksettings_add_link_mode(ks, supported, 569 1000baseT_Full); 570 break; 571 case ICE_PHY_TYPE_LOW_1000BASE_SX: 572 case ICE_PHY_TYPE_LOW_1000BASE_LX: 573 ethtool_link_ksettings_add_link_mode(ks, supported, 574 1000baseX_Full); 575 break; 576 case ICE_PHY_TYPE_LOW_1000BASE_KX: 577 ethtool_link_ksettings_add_link_mode(ks, supported, Autoneg); 578 ethtool_link_ksettings_add_link_mode(ks, supported, 579 1000baseKX_Full); 580 ethtool_link_ksettings_add_link_mode(ks, advertising, Autoneg); 581 ethtool_link_ksettings_add_link_mode(ks, advertising, 582 1000baseKX_Full); 583 break; 584 case ICE_PHY_TYPE_LOW_2500BASE_T: 585 ethtool_link_ksettings_add_link_mode(ks, supported, Autoneg); 586 ethtool_link_ksettings_add_link_mode(ks, advertising, Autoneg); 587 ethtool_link_ksettings_add_link_mode(ks, supported, 588 2500baseT_Full); 589 ethtool_link_ksettings_add_link_mode(ks, advertising, 590 2500baseT_Full); 591 break; 592 case ICE_PHY_TYPE_LOW_2500BASE_X: 593 ethtool_link_ksettings_add_link_mode(ks, supported, 594 2500baseX_Full); 595 break; 596 case ICE_PHY_TYPE_LOW_2500BASE_KX: 597 ethtool_link_ksettings_add_link_mode(ks, supported, Autoneg); 598 ethtool_link_ksettings_add_link_mode(ks, supported, 599 2500baseX_Full); 600 ethtool_link_ksettings_add_link_mode(ks, advertising, Autoneg); 601 ethtool_link_ksettings_add_link_mode(ks, advertising, 602 2500baseX_Full); 603 break; 604 case ICE_PHY_TYPE_LOW_5GBASE_T: 605 case ICE_PHY_TYPE_LOW_5GBASE_KR: 606 ethtool_link_ksettings_add_link_mode(ks, supported, Autoneg); 607 ethtool_link_ksettings_add_link_mode(ks, supported, 608 5000baseT_Full); 609 ethtool_link_ksettings_add_link_mode(ks, advertising, Autoneg); 610 ethtool_link_ksettings_add_link_mode(ks, advertising, 611 5000baseT_Full); 612 break; 613 case ICE_PHY_TYPE_LOW_10GBASE_T: 614 ethtool_link_ksettings_add_link_mode(ks, supported, Autoneg); 615 ethtool_link_ksettings_add_link_mode(ks, supported, 616 10000baseT_Full); 617 ethtool_link_ksettings_add_link_mode(ks, advertising, Autoneg); 618 ethtool_link_ksettings_add_link_mode(ks, advertising, 619 10000baseT_Full); 620 break; 621 case ICE_PHY_TYPE_LOW_10G_SFI_DA: 622 case ICE_PHY_TYPE_LOW_10G_SFI_AOC_ACC: 623 case ICE_PHY_TYPE_LOW_10G_SFI_C2C: 624 ethtool_link_ksettings_add_link_mode(ks, supported, 625 10000baseT_Full); 626 break; 627 case ICE_PHY_TYPE_LOW_10GBASE_SR: 628 ethtool_link_ksettings_add_link_mode(ks, supported, 629 10000baseSR_Full); 630 break; 631 case ICE_PHY_TYPE_LOW_10GBASE_LR: 632 ethtool_link_ksettings_add_link_mode(ks, supported, 633 10000baseLR_Full); 634 break; 635 case ICE_PHY_TYPE_LOW_10GBASE_KR_CR1: 636 ethtool_link_ksettings_add_link_mode(ks, supported, Autoneg); 637 ethtool_link_ksettings_add_link_mode(ks, supported, 638 10000baseKR_Full); 639 ethtool_link_ksettings_add_link_mode(ks, advertising, Autoneg); 640 ethtool_link_ksettings_add_link_mode(ks, advertising, 641 10000baseKR_Full); 642 break; 643 case ICE_PHY_TYPE_LOW_25GBASE_T: 644 case ICE_PHY_TYPE_LOW_25GBASE_CR: 645 case ICE_PHY_TYPE_LOW_25GBASE_CR_S: 646 case ICE_PHY_TYPE_LOW_25GBASE_CR1: 647 ethtool_link_ksettings_add_link_mode(ks, supported, Autoneg); 648 ethtool_link_ksettings_add_link_mode(ks, supported, 649 25000baseCR_Full); 650 ethtool_link_ksettings_add_link_mode(ks, advertising, Autoneg); 651 ethtool_link_ksettings_add_link_mode(ks, advertising, 652 25000baseCR_Full); 653 break; 654 case ICE_PHY_TYPE_LOW_25G_AUI_AOC_ACC: 655 ethtool_link_ksettings_add_link_mode(ks, supported, 656 25000baseCR_Full); 657 break; 658 case ICE_PHY_TYPE_LOW_25GBASE_SR: 659 case ICE_PHY_TYPE_LOW_25GBASE_LR: 660 ethtool_link_ksettings_add_link_mode(ks, supported, 661 25000baseSR_Full); 662 break; 663 case ICE_PHY_TYPE_LOW_25GBASE_KR: 664 case ICE_PHY_TYPE_LOW_25GBASE_KR1: 665 case ICE_PHY_TYPE_LOW_25GBASE_KR_S: 666 ethtool_link_ksettings_add_link_mode(ks, supported, Autoneg); 667 ethtool_link_ksettings_add_link_mode(ks, supported, 668 25000baseKR_Full); 669 ethtool_link_ksettings_add_link_mode(ks, advertising, Autoneg); 670 ethtool_link_ksettings_add_link_mode(ks, advertising, 671 25000baseKR_Full); 672 break; 673 case ICE_PHY_TYPE_LOW_40GBASE_CR4: 674 ethtool_link_ksettings_add_link_mode(ks, supported, Autoneg); 675 ethtool_link_ksettings_add_link_mode(ks, supported, 676 40000baseCR4_Full); 677 ethtool_link_ksettings_add_link_mode(ks, advertising, Autoneg); 678 ethtool_link_ksettings_add_link_mode(ks, advertising, 679 40000baseCR4_Full); 680 break; 681 case ICE_PHY_TYPE_LOW_40G_XLAUI_AOC_ACC: 682 case ICE_PHY_TYPE_LOW_40G_XLAUI: 683 ethtool_link_ksettings_add_link_mode(ks, supported, 684 40000baseCR4_Full); 685 break; 686 case ICE_PHY_TYPE_LOW_40GBASE_SR4: 687 ethtool_link_ksettings_add_link_mode(ks, supported, 688 40000baseSR4_Full); 689 break; 690 case ICE_PHY_TYPE_LOW_40GBASE_LR4: 691 ethtool_link_ksettings_add_link_mode(ks, supported, 692 40000baseLR4_Full); 693 break; 694 case ICE_PHY_TYPE_LOW_40GBASE_KR4: 695 ethtool_link_ksettings_add_link_mode(ks, supported, Autoneg); 696 ethtool_link_ksettings_add_link_mode(ks, supported, 697 40000baseKR4_Full); 698 ethtool_link_ksettings_add_link_mode(ks, advertising, Autoneg); 699 ethtool_link_ksettings_add_link_mode(ks, advertising, 700 40000baseKR4_Full); 701 break; 702 default: 703 unrecog_phy_low = true; 704 } 705 706 if (unrecog_phy_low) { 707 /* if we got here and link is up something bad is afoot */ 708 netdev_info(netdev, "WARNING: Unrecognized PHY_Low (0x%llx).\n", 709 (u64)link_info->phy_type_low); 710 } 711 712 /* Now that we've worked out everything that could be supported by the 713 * current PHY type, get what is supported by the NVM and intersect 714 * them to get what is truly supported 715 */ 716 memset(&cap_ksettings, 0, sizeof(struct ethtool_link_ksettings)); 717 ice_phy_type_to_ethtool(netdev, &cap_ksettings); 718 ethtool_intersect_link_masks(ks, &cap_ksettings); 719 720 switch (link_info->link_speed) { 721 case ICE_AQ_LINK_SPEED_40GB: 722 ks->base.speed = SPEED_40000; 723 break; 724 case ICE_AQ_LINK_SPEED_25GB: 725 ks->base.speed = SPEED_25000; 726 break; 727 case ICE_AQ_LINK_SPEED_20GB: 728 ks->base.speed = SPEED_20000; 729 break; 730 case ICE_AQ_LINK_SPEED_10GB: 731 ks->base.speed = SPEED_10000; 732 break; 733 case ICE_AQ_LINK_SPEED_5GB: 734 ks->base.speed = SPEED_5000; 735 break; 736 case ICE_AQ_LINK_SPEED_2500MB: 737 ks->base.speed = SPEED_2500; 738 break; 739 case ICE_AQ_LINK_SPEED_1000MB: 740 ks->base.speed = SPEED_1000; 741 break; 742 case ICE_AQ_LINK_SPEED_100MB: 743 ks->base.speed = SPEED_100; 744 break; 745 default: 746 netdev_info(netdev, 747 "WARNING: Unrecognized link_speed (0x%x).\n", 748 link_info->link_speed); 749 break; 750 } 751 ks->base.duplex = DUPLEX_FULL; 752 } 753 754 /** 755 * ice_get_settings_link_down - Get the Link settings when link is down 756 * @ks: ethtool ksettings to fill in 757 * @netdev: network interface device structure 758 * 759 * Reports link settings that can be determined when link is down 760 */ 761 static void 762 ice_get_settings_link_down(struct ethtool_link_ksettings *ks, 763 struct net_device __always_unused *netdev) 764 { 765 /* link is down and the driver needs to fall back on 766 * supported phy types to figure out what info to display 767 */ 768 ice_phy_type_to_ethtool(netdev, ks); 769 770 /* With no link, speed and duplex are unknown */ 771 ks->base.speed = SPEED_UNKNOWN; 772 ks->base.duplex = DUPLEX_UNKNOWN; 773 } 774 775 /** 776 * ice_get_link_ksettings - Get Link Speed and Duplex settings 777 * @netdev: network interface device structure 778 * @ks: ethtool ksettings 779 * 780 * Reports speed/duplex settings based on media_type 781 */ 782 static int ice_get_link_ksettings(struct net_device *netdev, 783 struct ethtool_link_ksettings *ks) 784 { 785 struct ice_netdev_priv *np = netdev_priv(netdev); 786 struct ice_link_status *hw_link_info; 787 struct ice_vsi *vsi = np->vsi; 788 789 ethtool_link_ksettings_zero_link_mode(ks, supported); 790 ethtool_link_ksettings_zero_link_mode(ks, advertising); 791 hw_link_info = &vsi->port_info->phy.link_info; 792 793 /* set speed and duplex */ 794 if (hw_link_info->link_info & ICE_AQ_LINK_UP) 795 ice_get_settings_link_up(ks, netdev); 796 else 797 ice_get_settings_link_down(ks, netdev); 798 799 /* set autoneg settings */ 800 ks->base.autoneg = (hw_link_info->an_info & ICE_AQ_AN_COMPLETED) ? 801 AUTONEG_ENABLE : AUTONEG_DISABLE; 802 803 /* set media type settings */ 804 switch (vsi->port_info->phy.media_type) { 805 case ICE_MEDIA_FIBER: 806 ethtool_link_ksettings_add_link_mode(ks, supported, FIBRE); 807 ks->base.port = PORT_FIBRE; 808 break; 809 case ICE_MEDIA_BASET: 810 ethtool_link_ksettings_add_link_mode(ks, supported, TP); 811 ethtool_link_ksettings_add_link_mode(ks, advertising, TP); 812 ks->base.port = PORT_TP; 813 break; 814 case ICE_MEDIA_BACKPLANE: 815 ethtool_link_ksettings_add_link_mode(ks, supported, Autoneg); 816 ethtool_link_ksettings_add_link_mode(ks, supported, Backplane); 817 ethtool_link_ksettings_add_link_mode(ks, advertising, Autoneg); 818 ethtool_link_ksettings_add_link_mode(ks, advertising, 819 Backplane); 820 ks->base.port = PORT_NONE; 821 break; 822 case ICE_MEDIA_DA: 823 ethtool_link_ksettings_add_link_mode(ks, supported, FIBRE); 824 ethtool_link_ksettings_add_link_mode(ks, advertising, FIBRE); 825 ks->base.port = PORT_DA; 826 break; 827 default: 828 ks->base.port = PORT_OTHER; 829 break; 830 } 831 832 /* flow control is symmetric and always supported */ 833 ethtool_link_ksettings_add_link_mode(ks, supported, Pause); 834 835 switch (vsi->port_info->fc.req_mode) { 836 case ICE_FC_FULL: 837 ethtool_link_ksettings_add_link_mode(ks, advertising, Pause); 838 break; 839 case ICE_FC_TX_PAUSE: 840 ethtool_link_ksettings_add_link_mode(ks, advertising, 841 Asym_Pause); 842 break; 843 case ICE_FC_RX_PAUSE: 844 ethtool_link_ksettings_add_link_mode(ks, advertising, Pause); 845 ethtool_link_ksettings_add_link_mode(ks, advertising, 846 Asym_Pause); 847 break; 848 case ICE_FC_PFC: 849 default: 850 ethtool_link_ksettings_del_link_mode(ks, advertising, Pause); 851 ethtool_link_ksettings_del_link_mode(ks, advertising, 852 Asym_Pause); 853 break; 854 } 855 856 return 0; 857 } 858 859 /** 860 * ice_ksettings_find_adv_link_speed - Find advertising link speed 861 * @ks: ethtool ksettings 862 */ 863 static u16 864 ice_ksettings_find_adv_link_speed(const struct ethtool_link_ksettings *ks) 865 { 866 u16 adv_link_speed = 0; 867 868 if (ethtool_link_ksettings_test_link_mode(ks, advertising, 869 100baseT_Full)) 870 adv_link_speed |= ICE_AQ_LINK_SPEED_100MB; 871 if (ethtool_link_ksettings_test_link_mode(ks, advertising, 872 1000baseX_Full)) 873 adv_link_speed |= ICE_AQ_LINK_SPEED_1000MB; 874 if (ethtool_link_ksettings_test_link_mode(ks, advertising, 875 1000baseT_Full) || 876 ethtool_link_ksettings_test_link_mode(ks, advertising, 877 1000baseKX_Full)) 878 adv_link_speed |= ICE_AQ_LINK_SPEED_1000MB; 879 if (ethtool_link_ksettings_test_link_mode(ks, advertising, 880 2500baseT_Full)) 881 adv_link_speed |= ICE_AQ_LINK_SPEED_2500MB; 882 if (ethtool_link_ksettings_test_link_mode(ks, advertising, 883 2500baseX_Full)) 884 adv_link_speed |= ICE_AQ_LINK_SPEED_2500MB; 885 if (ethtool_link_ksettings_test_link_mode(ks, advertising, 886 5000baseT_Full)) 887 adv_link_speed |= ICE_AQ_LINK_SPEED_5GB; 888 if (ethtool_link_ksettings_test_link_mode(ks, advertising, 889 10000baseT_Full) || 890 ethtool_link_ksettings_test_link_mode(ks, advertising, 891 10000baseKR_Full)) 892 adv_link_speed |= ICE_AQ_LINK_SPEED_10GB; 893 if (ethtool_link_ksettings_test_link_mode(ks, advertising, 894 10000baseSR_Full) || 895 ethtool_link_ksettings_test_link_mode(ks, advertising, 896 10000baseLR_Full)) 897 adv_link_speed |= ICE_AQ_LINK_SPEED_10GB; 898 if (ethtool_link_ksettings_test_link_mode(ks, advertising, 899 25000baseCR_Full) || 900 ethtool_link_ksettings_test_link_mode(ks, advertising, 901 25000baseSR_Full) || 902 ethtool_link_ksettings_test_link_mode(ks, advertising, 903 25000baseKR_Full)) 904 adv_link_speed |= ICE_AQ_LINK_SPEED_25GB; 905 if (ethtool_link_ksettings_test_link_mode(ks, advertising, 906 40000baseCR4_Full) || 907 ethtool_link_ksettings_test_link_mode(ks, advertising, 908 40000baseSR4_Full) || 909 ethtool_link_ksettings_test_link_mode(ks, advertising, 910 40000baseLR4_Full) || 911 ethtool_link_ksettings_test_link_mode(ks, advertising, 912 40000baseKR4_Full)) 913 adv_link_speed |= ICE_AQ_LINK_SPEED_40GB; 914 915 return adv_link_speed; 916 } 917 918 /** 919 * ice_setup_autoneg 920 * @p: port info 921 * @ks: ethtool_link_ksettings 922 * @config: configuration that will be sent down to FW 923 * @autoneg_enabled: autonegotiation is enabled or not 924 * @autoneg_changed: will there a change in autonegotiation 925 * @netdev: network interface device structure 926 * 927 * Setup PHY autonegotiation feature 928 */ 929 static int 930 ice_setup_autoneg(struct ice_port_info *p, struct ethtool_link_ksettings *ks, 931 struct ice_aqc_set_phy_cfg_data *config, 932 u8 autoneg_enabled, u8 *autoneg_changed, 933 struct net_device *netdev) 934 { 935 int err = 0; 936 937 *autoneg_changed = 0; 938 939 /* Check autoneg */ 940 if (autoneg_enabled == AUTONEG_ENABLE) { 941 /* If autoneg was not already enabled */ 942 if (!(p->phy.link_info.an_info & ICE_AQ_AN_COMPLETED)) { 943 /* If autoneg is not supported, return error */ 944 if (!ethtool_link_ksettings_test_link_mode(ks, 945 supported, 946 Autoneg)) { 947 netdev_info(netdev, "Autoneg not supported on this phy.\n"); 948 err = -EINVAL; 949 } else { 950 /* Autoneg is allowed to change */ 951 config->caps |= ICE_AQ_PHY_ENA_AUTO_LINK_UPDT; 952 *autoneg_changed = 1; 953 } 954 } 955 } else { 956 /* If autoneg is currently enabled */ 957 if (p->phy.link_info.an_info & ICE_AQ_AN_COMPLETED) { 958 /* If autoneg is supported 10GBASE_T is the only phy 959 * that can disable it, so otherwise return error 960 */ 961 if (ethtool_link_ksettings_test_link_mode(ks, 962 supported, 963 Autoneg)) { 964 netdev_info(netdev, "Autoneg cannot be disabled on this phy\n"); 965 err = -EINVAL; 966 } else { 967 /* Autoneg is allowed to change */ 968 config->caps &= ~ICE_AQ_PHY_ENA_AUTO_LINK_UPDT; 969 *autoneg_changed = 1; 970 } 971 } 972 } 973 974 return err; 975 } 976 977 /** 978 * ice_set_link_ksettings - Set Speed and Duplex 979 * @netdev: network interface device structure 980 * @ks: ethtool ksettings 981 * 982 * Set speed/duplex per media_types advertised/forced 983 */ 984 static int ice_set_link_ksettings(struct net_device *netdev, 985 const struct ethtool_link_ksettings *ks) 986 { 987 u8 autoneg, timeout = TEST_SET_BITS_TIMEOUT, lport = 0; 988 struct ice_netdev_priv *np = netdev_priv(netdev); 989 struct ethtool_link_ksettings safe_ks, copy_ks; 990 struct ice_aqc_get_phy_caps_data *abilities; 991 u16 adv_link_speed, curr_link_speed, idx; 992 struct ice_aqc_set_phy_cfg_data config; 993 struct ice_pf *pf = np->vsi->back; 994 struct ice_port_info *p; 995 u8 autoneg_changed = 0; 996 enum ice_status status; 997 u64 phy_type_low; 998 int err = 0; 999 bool linkup; 1000 1001 p = np->vsi->port_info; 1002 1003 if (!p) 1004 return -EOPNOTSUPP; 1005 1006 /* Check if this is lan vsi */ 1007 for (idx = 0 ; idx < pf->num_alloc_vsi ; idx++) { 1008 if (pf->vsi[idx]->type == ICE_VSI_PF) { 1009 if (np->vsi != pf->vsi[idx]) 1010 return -EOPNOTSUPP; 1011 break; 1012 } 1013 } 1014 1015 if (p->phy.media_type != ICE_MEDIA_BASET && 1016 p->phy.media_type != ICE_MEDIA_FIBER && 1017 p->phy.media_type != ICE_MEDIA_BACKPLANE && 1018 p->phy.media_type != ICE_MEDIA_DA && 1019 p->phy.link_info.link_info & ICE_AQ_LINK_UP) 1020 return -EOPNOTSUPP; 1021 1022 /* copy the ksettings to copy_ks to avoid modifying the original */ 1023 memcpy(©_ks, ks, sizeof(struct ethtool_link_ksettings)); 1024 1025 /* save autoneg out of ksettings */ 1026 autoneg = copy_ks.base.autoneg; 1027 1028 memset(&safe_ks, 0, sizeof(safe_ks)); 1029 1030 /* Get link modes supported by hardware.*/ 1031 ice_phy_type_to_ethtool(netdev, &safe_ks); 1032 1033 /* and check against modes requested by user. 1034 * Return an error if unsupported mode was set. 1035 */ 1036 if (!bitmap_subset(copy_ks.link_modes.advertising, 1037 safe_ks.link_modes.supported, 1038 __ETHTOOL_LINK_MODE_MASK_NBITS)) 1039 return -EINVAL; 1040 1041 /* get our own copy of the bits to check against */ 1042 memset(&safe_ks, 0, sizeof(struct ethtool_link_ksettings)); 1043 safe_ks.base.cmd = copy_ks.base.cmd; 1044 safe_ks.base.link_mode_masks_nwords = 1045 copy_ks.base.link_mode_masks_nwords; 1046 ice_get_link_ksettings(netdev, &safe_ks); 1047 1048 /* set autoneg back to what it currently is */ 1049 copy_ks.base.autoneg = safe_ks.base.autoneg; 1050 /* we don't compare the speed */ 1051 copy_ks.base.speed = safe_ks.base.speed; 1052 1053 /* If copy_ks.base and safe_ks.base are not the same now, then they are 1054 * trying to set something that we do not support. 1055 */ 1056 if (memcmp(©_ks.base, &safe_ks.base, 1057 sizeof(struct ethtool_link_settings))) 1058 return -EOPNOTSUPP; 1059 1060 while (test_and_set_bit(__ICE_CFG_BUSY, pf->state)) { 1061 timeout--; 1062 if (!timeout) 1063 return -EBUSY; 1064 usleep_range(TEST_SET_BITS_SLEEP_MIN, TEST_SET_BITS_SLEEP_MAX); 1065 } 1066 1067 abilities = devm_kzalloc(&pf->pdev->dev, sizeof(*abilities), 1068 GFP_KERNEL); 1069 if (!abilities) 1070 return -ENOMEM; 1071 1072 /* Get the current phy config */ 1073 status = ice_aq_get_phy_caps(p, false, ICE_AQC_REPORT_SW_CFG, abilities, 1074 NULL); 1075 if (status) { 1076 err = -EAGAIN; 1077 goto done; 1078 } 1079 1080 /* Copy abilities to config in case autoneg is not set below */ 1081 memset(&config, 0, sizeof(struct ice_aqc_set_phy_cfg_data)); 1082 config.caps = abilities->caps & ~ICE_AQC_PHY_AN_MODE; 1083 if (abilities->caps & ICE_AQC_PHY_AN_MODE) 1084 config.caps |= ICE_AQ_PHY_ENA_AUTO_LINK_UPDT; 1085 1086 /* Check autoneg */ 1087 err = ice_setup_autoneg(p, &safe_ks, &config, autoneg, &autoneg_changed, 1088 netdev); 1089 1090 if (err) 1091 goto done; 1092 1093 /* Call to get the current link speed */ 1094 p->phy.get_link_info = true; 1095 status = ice_get_link_status(p, &linkup); 1096 if (status) { 1097 err = -EAGAIN; 1098 goto done; 1099 } 1100 1101 curr_link_speed = p->phy.link_info.link_speed; 1102 adv_link_speed = ice_ksettings_find_adv_link_speed(ks); 1103 1104 /* If speed didn't get set, set it to what it currently is. 1105 * This is needed because if advertise is 0 (as it is when autoneg 1106 * is disabled) then speed won't get set. 1107 */ 1108 if (!adv_link_speed) 1109 adv_link_speed = curr_link_speed; 1110 1111 /* Convert the advertise link speeds to their corresponded PHY_TYPE */ 1112 ice_update_phy_type(&phy_type_low, adv_link_speed); 1113 1114 if (!autoneg_changed && adv_link_speed == curr_link_speed) { 1115 netdev_info(netdev, "Nothing changed, exiting without setting anything.\n"); 1116 goto done; 1117 } 1118 1119 /* copy over the rest of the abilities */ 1120 config.low_power_ctrl = abilities->low_power_ctrl; 1121 config.eee_cap = abilities->eee_cap; 1122 config.eeer_value = abilities->eeer_value; 1123 config.link_fec_opt = abilities->link_fec_options; 1124 1125 /* save the requested speeds */ 1126 p->phy.link_info.req_speeds = adv_link_speed; 1127 1128 /* set link and auto negotiation so changes take effect */ 1129 config.caps |= ICE_AQ_PHY_ENA_LINK; 1130 1131 if (phy_type_low) { 1132 config.phy_type_low = cpu_to_le64(phy_type_low) & 1133 abilities->phy_type_low; 1134 } else { 1135 err = -EAGAIN; 1136 netdev_info(netdev, "Nothing changed. No PHY_TYPE is corresponded to advertised link speed.\n"); 1137 goto done; 1138 } 1139 1140 /* If link is up put link down */ 1141 if (p->phy.link_info.link_info & ICE_AQ_LINK_UP) { 1142 /* Tell the OS link is going down, the link will go 1143 * back up when fw says it is ready asynchronously 1144 */ 1145 ice_print_link_msg(np->vsi, false); 1146 netif_carrier_off(netdev); 1147 netif_tx_stop_all_queues(netdev); 1148 } 1149 1150 /* make the aq call */ 1151 status = ice_aq_set_phy_cfg(&pf->hw, lport, &config, NULL); 1152 if (status) { 1153 netdev_info(netdev, "Set phy config failed,\n"); 1154 err = -EAGAIN; 1155 } 1156 1157 done: 1158 devm_kfree(&pf->pdev->dev, abilities); 1159 clear_bit(__ICE_CFG_BUSY, pf->state); 1160 1161 return err; 1162 } 1163 1164 /** 1165 * ice_get_rxnfc - command to get RX flow classification rules 1166 * @netdev: network interface device structure 1167 * @cmd: ethtool rxnfc command 1168 * @rule_locs: buffer to rturn Rx flow classification rules 1169 * 1170 * Returns Success if the command is supported. 1171 */ 1172 static int ice_get_rxnfc(struct net_device *netdev, struct ethtool_rxnfc *cmd, 1173 u32 __always_unused *rule_locs) 1174 { 1175 struct ice_netdev_priv *np = netdev_priv(netdev); 1176 struct ice_vsi *vsi = np->vsi; 1177 int ret = -EOPNOTSUPP; 1178 1179 switch (cmd->cmd) { 1180 case ETHTOOL_GRXRINGS: 1181 cmd->data = vsi->rss_size; 1182 ret = 0; 1183 break; 1184 default: 1185 break; 1186 } 1187 1188 return ret; 1189 } 1190 1191 static void 1192 ice_get_ringparam(struct net_device *netdev, struct ethtool_ringparam *ring) 1193 { 1194 struct ice_netdev_priv *np = netdev_priv(netdev); 1195 struct ice_vsi *vsi = np->vsi; 1196 1197 ring->rx_max_pending = ICE_MAX_NUM_DESC; 1198 ring->tx_max_pending = ICE_MAX_NUM_DESC; 1199 ring->rx_pending = vsi->rx_rings[0]->count; 1200 ring->tx_pending = vsi->tx_rings[0]->count; 1201 1202 /* Rx mini and jumbo rings are not supported */ 1203 ring->rx_mini_max_pending = 0; 1204 ring->rx_jumbo_max_pending = 0; 1205 ring->rx_mini_pending = 0; 1206 ring->rx_jumbo_pending = 0; 1207 } 1208 1209 static int 1210 ice_set_ringparam(struct net_device *netdev, struct ethtool_ringparam *ring) 1211 { 1212 struct ice_ring *tx_rings = NULL, *rx_rings = NULL; 1213 struct ice_netdev_priv *np = netdev_priv(netdev); 1214 struct ice_vsi *vsi = np->vsi; 1215 struct ice_pf *pf = vsi->back; 1216 int i, timeout = 50, err = 0; 1217 u32 new_rx_cnt, new_tx_cnt; 1218 1219 if (ring->tx_pending > ICE_MAX_NUM_DESC || 1220 ring->tx_pending < ICE_MIN_NUM_DESC || 1221 ring->rx_pending > ICE_MAX_NUM_DESC || 1222 ring->rx_pending < ICE_MIN_NUM_DESC) { 1223 netdev_err(netdev, "Descriptors requested (Tx: %d / Rx: %d) out of range [%d-%d] (increment %d)\n", 1224 ring->tx_pending, ring->rx_pending, 1225 ICE_MIN_NUM_DESC, ICE_MAX_NUM_DESC, 1226 ICE_REQ_DESC_MULTIPLE); 1227 return -EINVAL; 1228 } 1229 1230 new_tx_cnt = ALIGN(ring->tx_pending, ICE_REQ_DESC_MULTIPLE); 1231 if (new_tx_cnt != ring->tx_pending) 1232 netdev_info(netdev, 1233 "Requested Tx descriptor count rounded up to %d\n", 1234 new_tx_cnt); 1235 new_rx_cnt = ALIGN(ring->rx_pending, ICE_REQ_DESC_MULTIPLE); 1236 if (new_rx_cnt != ring->rx_pending) 1237 netdev_info(netdev, 1238 "Requested Rx descriptor count rounded up to %d\n", 1239 new_rx_cnt); 1240 1241 /* if nothing to do return success */ 1242 if (new_tx_cnt == vsi->tx_rings[0]->count && 1243 new_rx_cnt == vsi->rx_rings[0]->count) { 1244 netdev_dbg(netdev, "Nothing to change, descriptor count is same as requested\n"); 1245 return 0; 1246 } 1247 1248 while (test_and_set_bit(__ICE_CFG_BUSY, pf->state)) { 1249 timeout--; 1250 if (!timeout) 1251 return -EBUSY; 1252 usleep_range(1000, 2000); 1253 } 1254 1255 /* set for the next time the netdev is started */ 1256 if (!netif_running(vsi->netdev)) { 1257 for (i = 0; i < vsi->alloc_txq; i++) 1258 vsi->tx_rings[i]->count = new_tx_cnt; 1259 for (i = 0; i < vsi->alloc_rxq; i++) 1260 vsi->rx_rings[i]->count = new_rx_cnt; 1261 netdev_dbg(netdev, "Link is down, descriptor count change happens when link is brought up\n"); 1262 goto done; 1263 } 1264 1265 if (new_tx_cnt == vsi->tx_rings[0]->count) 1266 goto process_rx; 1267 1268 /* alloc updated Tx resources */ 1269 netdev_info(netdev, "Changing Tx descriptor count from %d to %d\n", 1270 vsi->tx_rings[0]->count, new_tx_cnt); 1271 1272 tx_rings = devm_kcalloc(&pf->pdev->dev, vsi->alloc_txq, 1273 sizeof(struct ice_ring), GFP_KERNEL); 1274 if (!tx_rings) { 1275 err = -ENOMEM; 1276 goto done; 1277 } 1278 1279 for (i = 0; i < vsi->alloc_txq; i++) { 1280 /* clone ring and setup updated count */ 1281 tx_rings[i] = *vsi->tx_rings[i]; 1282 tx_rings[i].count = new_tx_cnt; 1283 tx_rings[i].desc = NULL; 1284 tx_rings[i].tx_buf = NULL; 1285 err = ice_setup_tx_ring(&tx_rings[i]); 1286 if (err) { 1287 while (i) { 1288 i--; 1289 ice_clean_tx_ring(&tx_rings[i]); 1290 } 1291 devm_kfree(&pf->pdev->dev, tx_rings); 1292 goto done; 1293 } 1294 } 1295 1296 process_rx: 1297 if (new_rx_cnt == vsi->rx_rings[0]->count) 1298 goto process_link; 1299 1300 /* alloc updated Rx resources */ 1301 netdev_info(netdev, "Changing Rx descriptor count from %d to %d\n", 1302 vsi->rx_rings[0]->count, new_rx_cnt); 1303 1304 rx_rings = devm_kcalloc(&pf->pdev->dev, vsi->alloc_rxq, 1305 sizeof(struct ice_ring), GFP_KERNEL); 1306 if (!rx_rings) { 1307 err = -ENOMEM; 1308 goto done; 1309 } 1310 1311 for (i = 0; i < vsi->alloc_rxq; i++) { 1312 /* clone ring and setup updated count */ 1313 rx_rings[i] = *vsi->rx_rings[i]; 1314 rx_rings[i].count = new_rx_cnt; 1315 rx_rings[i].desc = NULL; 1316 rx_rings[i].rx_buf = NULL; 1317 /* this is to allow wr32 to have something to write to 1318 * during early allocation of Rx buffers 1319 */ 1320 rx_rings[i].tail = vsi->back->hw.hw_addr + PRTGEN_STATUS; 1321 1322 err = ice_setup_rx_ring(&rx_rings[i]); 1323 if (err) 1324 goto rx_unwind; 1325 1326 /* allocate Rx buffers */ 1327 err = ice_alloc_rx_bufs(&rx_rings[i], 1328 ICE_DESC_UNUSED(&rx_rings[i])); 1329 rx_unwind: 1330 if (err) { 1331 while (i) { 1332 i--; 1333 ice_free_rx_ring(&rx_rings[i]); 1334 } 1335 devm_kfree(&pf->pdev->dev, rx_rings); 1336 err = -ENOMEM; 1337 goto free_tx; 1338 } 1339 } 1340 1341 process_link: 1342 /* Bring interface down, copy in the new ring info, then restore the 1343 * interface. if VSI is up, bring it down and then back up 1344 */ 1345 if (!test_and_set_bit(__ICE_DOWN, vsi->state)) { 1346 ice_down(vsi); 1347 1348 if (tx_rings) { 1349 for (i = 0; i < vsi->alloc_txq; i++) { 1350 ice_free_tx_ring(vsi->tx_rings[i]); 1351 *vsi->tx_rings[i] = tx_rings[i]; 1352 } 1353 devm_kfree(&pf->pdev->dev, tx_rings); 1354 } 1355 1356 if (rx_rings) { 1357 for (i = 0; i < vsi->alloc_rxq; i++) { 1358 ice_free_rx_ring(vsi->rx_rings[i]); 1359 /* copy the real tail offset */ 1360 rx_rings[i].tail = vsi->rx_rings[i]->tail; 1361 /* this is to fake out the allocation routine 1362 * into thinking it has to realloc everything 1363 * but the recycling logic will let us re-use 1364 * the buffers allocated above 1365 */ 1366 rx_rings[i].next_to_use = 0; 1367 rx_rings[i].next_to_clean = 0; 1368 rx_rings[i].next_to_alloc = 0; 1369 *vsi->rx_rings[i] = rx_rings[i]; 1370 } 1371 devm_kfree(&pf->pdev->dev, rx_rings); 1372 } 1373 1374 ice_up(vsi); 1375 } 1376 goto done; 1377 1378 free_tx: 1379 /* error cleanup if the Rx allocations failed after getting Tx */ 1380 if (tx_rings) { 1381 for (i = 0; i < vsi->alloc_txq; i++) 1382 ice_free_tx_ring(&tx_rings[i]); 1383 devm_kfree(&pf->pdev->dev, tx_rings); 1384 } 1385 1386 done: 1387 clear_bit(__ICE_CFG_BUSY, pf->state); 1388 return err; 1389 } 1390 1391 static int ice_nway_reset(struct net_device *netdev) 1392 { 1393 /* restart autonegotiation */ 1394 struct ice_netdev_priv *np = netdev_priv(netdev); 1395 struct ice_link_status *hw_link_info; 1396 struct ice_vsi *vsi = np->vsi; 1397 struct ice_port_info *pi; 1398 enum ice_status status; 1399 bool link_up; 1400 1401 pi = vsi->port_info; 1402 hw_link_info = &pi->phy.link_info; 1403 link_up = hw_link_info->link_info & ICE_AQ_LINK_UP; 1404 1405 status = ice_aq_set_link_restart_an(pi, link_up, NULL); 1406 if (status) { 1407 netdev_info(netdev, "link restart failed, err %d aq_err %d\n", 1408 status, pi->hw->adminq.sq_last_status); 1409 return -EIO; 1410 } 1411 1412 return 0; 1413 } 1414 1415 /** 1416 * ice_get_pauseparam - Get Flow Control status 1417 * @netdev: network interface device structure 1418 * @pause: ethernet pause (flow control) parameters 1419 */ 1420 static void 1421 ice_get_pauseparam(struct net_device *netdev, struct ethtool_pauseparam *pause) 1422 { 1423 struct ice_netdev_priv *np = netdev_priv(netdev); 1424 struct ice_port_info *pi; 1425 1426 pi = np->vsi->port_info; 1427 pause->autoneg = 1428 ((pi->phy.link_info.an_info & ICE_AQ_AN_COMPLETED) ? 1429 AUTONEG_ENABLE : AUTONEG_DISABLE); 1430 1431 if (pi->fc.current_mode == ICE_FC_RX_PAUSE) { 1432 pause->rx_pause = 1; 1433 } else if (pi->fc.current_mode == ICE_FC_TX_PAUSE) { 1434 pause->tx_pause = 1; 1435 } else if (pi->fc.current_mode == ICE_FC_FULL) { 1436 pause->rx_pause = 1; 1437 pause->tx_pause = 1; 1438 } 1439 } 1440 1441 /** 1442 * ice_set_pauseparam - Set Flow Control parameter 1443 * @netdev: network interface device structure 1444 * @pause: return tx/rx flow control status 1445 */ 1446 static int 1447 ice_set_pauseparam(struct net_device *netdev, struct ethtool_pauseparam *pause) 1448 { 1449 struct ice_netdev_priv *np = netdev_priv(netdev); 1450 struct ice_link_status *hw_link_info; 1451 struct ice_pf *pf = np->vsi->back; 1452 struct ice_vsi *vsi = np->vsi; 1453 struct ice_hw *hw = &pf->hw; 1454 struct ice_port_info *pi; 1455 enum ice_status status; 1456 u8 aq_failures; 1457 bool link_up; 1458 int err = 0; 1459 1460 pi = vsi->port_info; 1461 hw_link_info = &pi->phy.link_info; 1462 link_up = hw_link_info->link_info & ICE_AQ_LINK_UP; 1463 1464 /* Changing the port's flow control is not supported if this isn't the 1465 * PF VSI 1466 */ 1467 if (vsi->type != ICE_VSI_PF) { 1468 netdev_info(netdev, "Changing flow control parameters only supported for PF VSI\n"); 1469 return -EOPNOTSUPP; 1470 } 1471 1472 if (pause->autoneg != (hw_link_info->an_info & ICE_AQ_AN_COMPLETED)) { 1473 netdev_info(netdev, "To change autoneg please use: ethtool -s <dev> autoneg <on|off>\n"); 1474 return -EOPNOTSUPP; 1475 } 1476 1477 /* If we have link and don't have autoneg */ 1478 if (!test_bit(__ICE_DOWN, pf->state) && 1479 !(hw_link_info->an_info & ICE_AQ_AN_COMPLETED)) { 1480 /* Send message that it might not necessarily work*/ 1481 netdev_info(netdev, "Autoneg did not complete so changing settings may not result in an actual change.\n"); 1482 } 1483 1484 if (pause->rx_pause && pause->tx_pause) 1485 pi->fc.req_mode = ICE_FC_FULL; 1486 else if (pause->rx_pause && !pause->tx_pause) 1487 pi->fc.req_mode = ICE_FC_RX_PAUSE; 1488 else if (!pause->rx_pause && pause->tx_pause) 1489 pi->fc.req_mode = ICE_FC_TX_PAUSE; 1490 else if (!pause->rx_pause && !pause->tx_pause) 1491 pi->fc.req_mode = ICE_FC_NONE; 1492 else 1493 return -EINVAL; 1494 1495 /* Tell the OS link is going down, the link will go back up when fw 1496 * says it is ready asynchronously 1497 */ 1498 ice_print_link_msg(vsi, false); 1499 netif_carrier_off(netdev); 1500 netif_tx_stop_all_queues(netdev); 1501 1502 /* Set the FC mode and only restart AN if link is up */ 1503 status = ice_set_fc(pi, &aq_failures, link_up); 1504 1505 if (aq_failures & ICE_SET_FC_AQ_FAIL_GET) { 1506 netdev_info(netdev, "Set fc failed on the get_phy_capabilities call with err %d aq_err %d\n", 1507 status, hw->adminq.sq_last_status); 1508 err = -EAGAIN; 1509 } else if (aq_failures & ICE_SET_FC_AQ_FAIL_SET) { 1510 netdev_info(netdev, "Set fc failed on the set_phy_config call with err %d aq_err %d\n", 1511 status, hw->adminq.sq_last_status); 1512 err = -EAGAIN; 1513 } else if (aq_failures & ICE_SET_FC_AQ_FAIL_UPDATE) { 1514 netdev_info(netdev, "Set fc failed on the get_link_info call with err %d aq_err %d\n", 1515 status, hw->adminq.sq_last_status); 1516 err = -EAGAIN; 1517 } 1518 1519 if (!test_bit(__ICE_DOWN, pf->state)) { 1520 /* Give it a little more time to try to come back */ 1521 msleep(75); 1522 if (!test_bit(__ICE_DOWN, pf->state)) 1523 return ice_nway_reset(netdev); 1524 } 1525 1526 return err; 1527 } 1528 1529 /** 1530 * ice_get_rxfh_key_size - get the RSS hash key size 1531 * @netdev: network interface device structure 1532 * 1533 * Returns the table size. 1534 */ 1535 static u32 ice_get_rxfh_key_size(struct net_device __always_unused *netdev) 1536 { 1537 return ICE_VSIQF_HKEY_ARRAY_SIZE; 1538 } 1539 1540 /** 1541 * ice_get_rxfh_indir_size - get the rx flow hash indirection table size 1542 * @netdev: network interface device structure 1543 * 1544 * Returns the table size. 1545 */ 1546 static u32 ice_get_rxfh_indir_size(struct net_device *netdev) 1547 { 1548 struct ice_netdev_priv *np = netdev_priv(netdev); 1549 1550 return np->vsi->rss_table_size; 1551 } 1552 1553 /** 1554 * ice_get_rxfh - get the rx flow hash indirection table 1555 * @netdev: network interface device structure 1556 * @indir: indirection table 1557 * @key: hash key 1558 * @hfunc: hash function 1559 * 1560 * Reads the indirection table directly from the hardware. 1561 */ 1562 static int 1563 ice_get_rxfh(struct net_device *netdev, u32 *indir, u8 *key, u8 *hfunc) 1564 { 1565 struct ice_netdev_priv *np = netdev_priv(netdev); 1566 struct ice_vsi *vsi = np->vsi; 1567 struct ice_pf *pf = vsi->back; 1568 int ret = 0, i; 1569 u8 *lut; 1570 1571 if (hfunc) 1572 *hfunc = ETH_RSS_HASH_TOP; 1573 1574 if (!indir) 1575 return 0; 1576 1577 if (!test_bit(ICE_FLAG_RSS_ENA, pf->flags)) { 1578 /* RSS not supported return error here */ 1579 netdev_warn(netdev, "RSS is not configured on this VSI!\n"); 1580 return -EIO; 1581 } 1582 1583 lut = devm_kzalloc(&pf->pdev->dev, vsi->rss_table_size, GFP_KERNEL); 1584 if (!lut) 1585 return -ENOMEM; 1586 1587 if (ice_get_rss(vsi, key, lut, vsi->rss_table_size)) { 1588 ret = -EIO; 1589 goto out; 1590 } 1591 1592 for (i = 0; i < vsi->rss_table_size; i++) 1593 indir[i] = (u32)(lut[i]); 1594 1595 out: 1596 devm_kfree(&pf->pdev->dev, lut); 1597 return ret; 1598 } 1599 1600 /** 1601 * ice_set_rxfh - set the rx flow hash indirection table 1602 * @netdev: network interface device structure 1603 * @indir: indirection table 1604 * @key: hash key 1605 * @hfunc: hash function 1606 * 1607 * Returns -EINVAL if the table specifies an invalid queue id, otherwise 1608 * returns 0 after programming the table. 1609 */ 1610 static int ice_set_rxfh(struct net_device *netdev, const u32 *indir, 1611 const u8 *key, const u8 hfunc) 1612 { 1613 struct ice_netdev_priv *np = netdev_priv(netdev); 1614 struct ice_vsi *vsi = np->vsi; 1615 struct ice_pf *pf = vsi->back; 1616 u8 *seed = NULL; 1617 1618 if (hfunc != ETH_RSS_HASH_NO_CHANGE && hfunc != ETH_RSS_HASH_TOP) 1619 return -EOPNOTSUPP; 1620 1621 if (!test_bit(ICE_FLAG_RSS_ENA, pf->flags)) { 1622 /* RSS not supported return error here */ 1623 netdev_warn(netdev, "RSS is not configured on this VSI!\n"); 1624 return -EIO; 1625 } 1626 1627 if (key) { 1628 if (!vsi->rss_hkey_user) { 1629 vsi->rss_hkey_user = 1630 devm_kzalloc(&pf->pdev->dev, 1631 ICE_VSIQF_HKEY_ARRAY_SIZE, 1632 GFP_KERNEL); 1633 if (!vsi->rss_hkey_user) 1634 return -ENOMEM; 1635 } 1636 memcpy(vsi->rss_hkey_user, key, ICE_VSIQF_HKEY_ARRAY_SIZE); 1637 seed = vsi->rss_hkey_user; 1638 } 1639 1640 if (!vsi->rss_lut_user) { 1641 vsi->rss_lut_user = devm_kzalloc(&pf->pdev->dev, 1642 vsi->rss_table_size, 1643 GFP_KERNEL); 1644 if (!vsi->rss_lut_user) 1645 return -ENOMEM; 1646 } 1647 1648 /* Each 32 bits pointed by 'indir' is stored with a lut entry */ 1649 if (indir) { 1650 int i; 1651 1652 for (i = 0; i < vsi->rss_table_size; i++) 1653 vsi->rss_lut_user[i] = (u8)(indir[i]); 1654 } else { 1655 ice_fill_rss_lut(vsi->rss_lut_user, vsi->rss_table_size, 1656 vsi->rss_size); 1657 } 1658 1659 if (ice_set_rss(vsi, seed, vsi->rss_lut_user, vsi->rss_table_size)) 1660 return -EIO; 1661 1662 return 0; 1663 } 1664 1665 static const struct ethtool_ops ice_ethtool_ops = { 1666 .get_link_ksettings = ice_get_link_ksettings, 1667 .set_link_ksettings = ice_set_link_ksettings, 1668 .get_drvinfo = ice_get_drvinfo, 1669 .get_regs_len = ice_get_regs_len, 1670 .get_regs = ice_get_regs, 1671 .get_msglevel = ice_get_msglevel, 1672 .set_msglevel = ice_set_msglevel, 1673 .get_link = ethtool_op_get_link, 1674 .get_strings = ice_get_strings, 1675 .get_ethtool_stats = ice_get_ethtool_stats, 1676 .get_sset_count = ice_get_sset_count, 1677 .get_rxnfc = ice_get_rxnfc, 1678 .get_ringparam = ice_get_ringparam, 1679 .set_ringparam = ice_set_ringparam, 1680 .nway_reset = ice_nway_reset, 1681 .get_pauseparam = ice_get_pauseparam, 1682 .set_pauseparam = ice_set_pauseparam, 1683 .get_rxfh_key_size = ice_get_rxfh_key_size, 1684 .get_rxfh_indir_size = ice_get_rxfh_indir_size, 1685 .get_rxfh = ice_get_rxfh, 1686 .set_rxfh = ice_set_rxfh, 1687 }; 1688 1689 /** 1690 * ice_set_ethtool_ops - setup netdev ethtool ops 1691 * @netdev: network interface device structure 1692 * 1693 * setup netdev ethtool ops with ice specific ops 1694 */ 1695 void ice_set_ethtool_ops(struct net_device *netdev) 1696 { 1697 netdev->ethtool_ops = &ice_ethtool_ops; 1698 } 1699