1 /******************************************************************************* 2 3 Intel 82599 Virtual Function driver 4 Copyright(c) 1999 - 2018 Intel Corporation. 5 6 This program is free software; you can redistribute it and/or modify it 7 under the terms and conditions of the GNU General Public License, 8 version 2, as published by the Free Software Foundation. 9 10 This program is distributed in the hope it will be useful, but WITHOUT 11 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 12 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for 13 more details. 14 15 You should have received a copy of the GNU General Public License along with 16 this program; if not, see <http://www.gnu.org/licenses/>. 17 18 The full GNU General Public License is included in this distribution in 19 the file called "COPYING". 20 21 Contact Information: 22 e1000-devel Mailing List <e1000-devel@lists.sourceforge.net> 23 Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497 24 25 *******************************************************************************/ 26 27 /* ethtool support for ixgbevf */ 28 29 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 30 31 #include <linux/types.h> 32 #include <linux/module.h> 33 #include <linux/slab.h> 34 #include <linux/pci.h> 35 #include <linux/netdevice.h> 36 #include <linux/ethtool.h> 37 #include <linux/vmalloc.h> 38 #include <linux/if_vlan.h> 39 #include <linux/uaccess.h> 40 41 #include "ixgbevf.h" 42 43 #define IXGBE_ALL_RAR_ENTRIES 16 44 45 enum {NETDEV_STATS, IXGBEVF_STATS}; 46 47 struct ixgbe_stats { 48 char stat_string[ETH_GSTRING_LEN]; 49 int type; 50 int sizeof_stat; 51 int stat_offset; 52 }; 53 54 #define IXGBEVF_STAT(_name, _stat) { \ 55 .stat_string = _name, \ 56 .type = IXGBEVF_STATS, \ 57 .sizeof_stat = FIELD_SIZEOF(struct ixgbevf_adapter, _stat), \ 58 .stat_offset = offsetof(struct ixgbevf_adapter, _stat) \ 59 } 60 61 #define IXGBEVF_NETDEV_STAT(_net_stat) { \ 62 .stat_string = #_net_stat, \ 63 .type = NETDEV_STATS, \ 64 .sizeof_stat = FIELD_SIZEOF(struct net_device_stats, _net_stat), \ 65 .stat_offset = offsetof(struct net_device_stats, _net_stat) \ 66 } 67 68 static struct ixgbe_stats ixgbevf_gstrings_stats[] = { 69 IXGBEVF_NETDEV_STAT(rx_packets), 70 IXGBEVF_NETDEV_STAT(tx_packets), 71 IXGBEVF_NETDEV_STAT(rx_bytes), 72 IXGBEVF_NETDEV_STAT(tx_bytes), 73 IXGBEVF_STAT("tx_busy", tx_busy), 74 IXGBEVF_STAT("tx_restart_queue", restart_queue), 75 IXGBEVF_STAT("tx_timeout_count", tx_timeout_count), 76 IXGBEVF_NETDEV_STAT(multicast), 77 IXGBEVF_STAT("rx_csum_offload_errors", hw_csum_rx_error), 78 IXGBEVF_STAT("alloc_rx_page", alloc_rx_page), 79 IXGBEVF_STAT("alloc_rx_page_failed", alloc_rx_page_failed), 80 IXGBEVF_STAT("alloc_rx_buff_failed", alloc_rx_buff_failed), 81 }; 82 83 #define IXGBEVF_QUEUE_STATS_LEN ( \ 84 (((struct ixgbevf_adapter *)netdev_priv(netdev))->num_tx_queues + \ 85 ((struct ixgbevf_adapter *)netdev_priv(netdev))->num_xdp_queues + \ 86 ((struct ixgbevf_adapter *)netdev_priv(netdev))->num_rx_queues) * \ 87 (sizeof(struct ixgbevf_stats) / sizeof(u64))) 88 #define IXGBEVF_GLOBAL_STATS_LEN ARRAY_SIZE(ixgbevf_gstrings_stats) 89 90 #define IXGBEVF_STATS_LEN (IXGBEVF_GLOBAL_STATS_LEN + IXGBEVF_QUEUE_STATS_LEN) 91 static const char ixgbe_gstrings_test[][ETH_GSTRING_LEN] = { 92 "Register test (offline)", 93 "Link test (on/offline)" 94 }; 95 96 #define IXGBEVF_TEST_LEN (sizeof(ixgbe_gstrings_test) / ETH_GSTRING_LEN) 97 98 static const char ixgbevf_priv_flags_strings[][ETH_GSTRING_LEN] = { 99 #define IXGBEVF_PRIV_FLAGS_LEGACY_RX BIT(0) 100 "legacy-rx", 101 }; 102 103 #define IXGBEVF_PRIV_FLAGS_STR_LEN ARRAY_SIZE(ixgbevf_priv_flags_strings) 104 105 static int ixgbevf_get_link_ksettings(struct net_device *netdev, 106 struct ethtool_link_ksettings *cmd) 107 { 108 struct ixgbevf_adapter *adapter = netdev_priv(netdev); 109 struct ixgbe_hw *hw = &adapter->hw; 110 u32 link_speed = 0; 111 bool link_up; 112 113 ethtool_link_ksettings_zero_link_mode(cmd, supported); 114 ethtool_link_ksettings_add_link_mode(cmd, supported, 10000baseT_Full); 115 cmd->base.autoneg = AUTONEG_DISABLE; 116 cmd->base.port = -1; 117 118 hw->mac.get_link_status = 1; 119 hw->mac.ops.check_link(hw, &link_speed, &link_up, false); 120 121 if (link_up) { 122 __u32 speed = SPEED_10000; 123 124 switch (link_speed) { 125 case IXGBE_LINK_SPEED_10GB_FULL: 126 speed = SPEED_10000; 127 break; 128 case IXGBE_LINK_SPEED_1GB_FULL: 129 speed = SPEED_1000; 130 break; 131 case IXGBE_LINK_SPEED_100_FULL: 132 speed = SPEED_100; 133 break; 134 } 135 136 cmd->base.speed = speed; 137 cmd->base.duplex = DUPLEX_FULL; 138 } else { 139 cmd->base.speed = SPEED_UNKNOWN; 140 cmd->base.duplex = DUPLEX_UNKNOWN; 141 } 142 143 return 0; 144 } 145 146 static u32 ixgbevf_get_msglevel(struct net_device *netdev) 147 { 148 struct ixgbevf_adapter *adapter = netdev_priv(netdev); 149 150 return adapter->msg_enable; 151 } 152 153 static void ixgbevf_set_msglevel(struct net_device *netdev, u32 data) 154 { 155 struct ixgbevf_adapter *adapter = netdev_priv(netdev); 156 157 adapter->msg_enable = data; 158 } 159 160 #define IXGBE_GET_STAT(_A_, _R_) (_A_->stats._R_) 161 162 static int ixgbevf_get_regs_len(struct net_device *netdev) 163 { 164 #define IXGBE_REGS_LEN 45 165 return IXGBE_REGS_LEN * sizeof(u32); 166 } 167 168 static void ixgbevf_get_regs(struct net_device *netdev, 169 struct ethtool_regs *regs, 170 void *p) 171 { 172 struct ixgbevf_adapter *adapter = netdev_priv(netdev); 173 struct ixgbe_hw *hw = &adapter->hw; 174 u32 *regs_buff = p; 175 u32 regs_len = ixgbevf_get_regs_len(netdev); 176 u8 i; 177 178 memset(p, 0, regs_len); 179 180 /* generate a number suitable for ethtool's register version */ 181 regs->version = (1u << 24) | (hw->revision_id << 16) | hw->device_id; 182 183 /* General Registers */ 184 regs_buff[0] = IXGBE_READ_REG(hw, IXGBE_VFCTRL); 185 regs_buff[1] = IXGBE_READ_REG(hw, IXGBE_VFSTATUS); 186 regs_buff[2] = IXGBE_READ_REG(hw, IXGBE_VFLINKS); 187 regs_buff[3] = IXGBE_READ_REG(hw, IXGBE_VFRXMEMWRAP); 188 regs_buff[4] = IXGBE_READ_REG(hw, IXGBE_VFFRTIMER); 189 190 /* Interrupt */ 191 /* don't read EICR because it can clear interrupt causes, instead 192 * read EICS which is a shadow but doesn't clear EICR 193 */ 194 regs_buff[5] = IXGBE_READ_REG(hw, IXGBE_VTEICS); 195 regs_buff[6] = IXGBE_READ_REG(hw, IXGBE_VTEICS); 196 regs_buff[7] = IXGBE_READ_REG(hw, IXGBE_VTEIMS); 197 regs_buff[8] = IXGBE_READ_REG(hw, IXGBE_VTEIMC); 198 regs_buff[9] = IXGBE_READ_REG(hw, IXGBE_VTEIAC); 199 regs_buff[10] = IXGBE_READ_REG(hw, IXGBE_VTEIAM); 200 regs_buff[11] = IXGBE_READ_REG(hw, IXGBE_VTEITR(0)); 201 regs_buff[12] = IXGBE_READ_REG(hw, IXGBE_VTIVAR(0)); 202 regs_buff[13] = IXGBE_READ_REG(hw, IXGBE_VTIVAR_MISC); 203 204 /* Receive DMA */ 205 for (i = 0; i < 2; i++) 206 regs_buff[14 + i] = IXGBE_READ_REG(hw, IXGBE_VFRDBAL(i)); 207 for (i = 0; i < 2; i++) 208 regs_buff[16 + i] = IXGBE_READ_REG(hw, IXGBE_VFRDBAH(i)); 209 for (i = 0; i < 2; i++) 210 regs_buff[18 + i] = IXGBE_READ_REG(hw, IXGBE_VFRDLEN(i)); 211 for (i = 0; i < 2; i++) 212 regs_buff[20 + i] = IXGBE_READ_REG(hw, IXGBE_VFRDH(i)); 213 for (i = 0; i < 2; i++) 214 regs_buff[22 + i] = IXGBE_READ_REG(hw, IXGBE_VFRDT(i)); 215 for (i = 0; i < 2; i++) 216 regs_buff[24 + i] = IXGBE_READ_REG(hw, IXGBE_VFRXDCTL(i)); 217 for (i = 0; i < 2; i++) 218 regs_buff[26 + i] = IXGBE_READ_REG(hw, IXGBE_VFSRRCTL(i)); 219 220 /* Receive */ 221 regs_buff[28] = IXGBE_READ_REG(hw, IXGBE_VFPSRTYPE); 222 223 /* Transmit */ 224 for (i = 0; i < 2; i++) 225 regs_buff[29 + i] = IXGBE_READ_REG(hw, IXGBE_VFTDBAL(i)); 226 for (i = 0; i < 2; i++) 227 regs_buff[31 + i] = IXGBE_READ_REG(hw, IXGBE_VFTDBAH(i)); 228 for (i = 0; i < 2; i++) 229 regs_buff[33 + i] = IXGBE_READ_REG(hw, IXGBE_VFTDLEN(i)); 230 for (i = 0; i < 2; i++) 231 regs_buff[35 + i] = IXGBE_READ_REG(hw, IXGBE_VFTDH(i)); 232 for (i = 0; i < 2; i++) 233 regs_buff[37 + i] = IXGBE_READ_REG(hw, IXGBE_VFTDT(i)); 234 for (i = 0; i < 2; i++) 235 regs_buff[39 + i] = IXGBE_READ_REG(hw, IXGBE_VFTXDCTL(i)); 236 for (i = 0; i < 2; i++) 237 regs_buff[41 + i] = IXGBE_READ_REG(hw, IXGBE_VFTDWBAL(i)); 238 for (i = 0; i < 2; i++) 239 regs_buff[43 + i] = IXGBE_READ_REG(hw, IXGBE_VFTDWBAH(i)); 240 } 241 242 static void ixgbevf_get_drvinfo(struct net_device *netdev, 243 struct ethtool_drvinfo *drvinfo) 244 { 245 struct ixgbevf_adapter *adapter = netdev_priv(netdev); 246 247 strlcpy(drvinfo->driver, ixgbevf_driver_name, sizeof(drvinfo->driver)); 248 strlcpy(drvinfo->version, ixgbevf_driver_version, 249 sizeof(drvinfo->version)); 250 strlcpy(drvinfo->bus_info, pci_name(adapter->pdev), 251 sizeof(drvinfo->bus_info)); 252 253 drvinfo->n_priv_flags = IXGBEVF_PRIV_FLAGS_STR_LEN; 254 } 255 256 static void ixgbevf_get_ringparam(struct net_device *netdev, 257 struct ethtool_ringparam *ring) 258 { 259 struct ixgbevf_adapter *adapter = netdev_priv(netdev); 260 261 ring->rx_max_pending = IXGBEVF_MAX_RXD; 262 ring->tx_max_pending = IXGBEVF_MAX_TXD; 263 ring->rx_pending = adapter->rx_ring_count; 264 ring->tx_pending = adapter->tx_ring_count; 265 } 266 267 static int ixgbevf_set_ringparam(struct net_device *netdev, 268 struct ethtool_ringparam *ring) 269 { 270 struct ixgbevf_adapter *adapter = netdev_priv(netdev); 271 struct ixgbevf_ring *tx_ring = NULL, *rx_ring = NULL; 272 u32 new_rx_count, new_tx_count; 273 int i, j, err = 0; 274 275 if ((ring->rx_mini_pending) || (ring->rx_jumbo_pending)) 276 return -EINVAL; 277 278 new_tx_count = max_t(u32, ring->tx_pending, IXGBEVF_MIN_TXD); 279 new_tx_count = min_t(u32, new_tx_count, IXGBEVF_MAX_TXD); 280 new_tx_count = ALIGN(new_tx_count, IXGBE_REQ_TX_DESCRIPTOR_MULTIPLE); 281 282 new_rx_count = max_t(u32, ring->rx_pending, IXGBEVF_MIN_RXD); 283 new_rx_count = min_t(u32, new_rx_count, IXGBEVF_MAX_RXD); 284 new_rx_count = ALIGN(new_rx_count, IXGBE_REQ_RX_DESCRIPTOR_MULTIPLE); 285 286 /* if nothing to do return success */ 287 if ((new_tx_count == adapter->tx_ring_count) && 288 (new_rx_count == adapter->rx_ring_count)) 289 return 0; 290 291 while (test_and_set_bit(__IXGBEVF_RESETTING, &adapter->state)) 292 usleep_range(1000, 2000); 293 294 if (!netif_running(adapter->netdev)) { 295 for (i = 0; i < adapter->num_tx_queues; i++) 296 adapter->tx_ring[i]->count = new_tx_count; 297 for (i = 0; i < adapter->num_xdp_queues; i++) 298 adapter->xdp_ring[i]->count = new_tx_count; 299 for (i = 0; i < adapter->num_rx_queues; i++) 300 adapter->rx_ring[i]->count = new_rx_count; 301 adapter->tx_ring_count = new_tx_count; 302 adapter->xdp_ring_count = new_tx_count; 303 adapter->rx_ring_count = new_rx_count; 304 goto clear_reset; 305 } 306 307 if (new_tx_count != adapter->tx_ring_count) { 308 tx_ring = vmalloc((adapter->num_tx_queues + 309 adapter->num_xdp_queues) * sizeof(*tx_ring)); 310 if (!tx_ring) { 311 err = -ENOMEM; 312 goto clear_reset; 313 } 314 315 for (i = 0; i < adapter->num_tx_queues; i++) { 316 /* clone ring and setup updated count */ 317 tx_ring[i] = *adapter->tx_ring[i]; 318 tx_ring[i].count = new_tx_count; 319 err = ixgbevf_setup_tx_resources(&tx_ring[i]); 320 if (err) { 321 while (i) { 322 i--; 323 ixgbevf_free_tx_resources(&tx_ring[i]); 324 } 325 326 vfree(tx_ring); 327 tx_ring = NULL; 328 329 goto clear_reset; 330 } 331 } 332 333 for (j = 0; j < adapter->num_xdp_queues; i++, j++) { 334 /* clone ring and setup updated count */ 335 tx_ring[i] = *adapter->xdp_ring[j]; 336 tx_ring[i].count = new_tx_count; 337 err = ixgbevf_setup_tx_resources(&tx_ring[i]); 338 if (err) { 339 while (i) { 340 i--; 341 ixgbevf_free_tx_resources(&tx_ring[i]); 342 } 343 344 vfree(tx_ring); 345 tx_ring = NULL; 346 347 goto clear_reset; 348 } 349 } 350 } 351 352 if (new_rx_count != adapter->rx_ring_count) { 353 rx_ring = vmalloc(adapter->num_rx_queues * sizeof(*rx_ring)); 354 if (!rx_ring) { 355 err = -ENOMEM; 356 goto clear_reset; 357 } 358 359 for (i = 0; i < adapter->num_rx_queues; i++) { 360 /* clone ring and setup updated count */ 361 rx_ring[i] = *adapter->rx_ring[i]; 362 363 /* Clear copied XDP RX-queue info */ 364 memset(&rx_ring[i].xdp_rxq, 0, 365 sizeof(rx_ring[i].xdp_rxq)); 366 367 rx_ring[i].count = new_rx_count; 368 err = ixgbevf_setup_rx_resources(adapter, &rx_ring[i]); 369 if (err) { 370 while (i) { 371 i--; 372 ixgbevf_free_rx_resources(&rx_ring[i]); 373 } 374 375 vfree(rx_ring); 376 rx_ring = NULL; 377 378 goto clear_reset; 379 } 380 } 381 } 382 383 /* bring interface down to prepare for update */ 384 ixgbevf_down(adapter); 385 386 /* Tx */ 387 if (tx_ring) { 388 for (i = 0; i < adapter->num_tx_queues; i++) { 389 ixgbevf_free_tx_resources(adapter->tx_ring[i]); 390 *adapter->tx_ring[i] = tx_ring[i]; 391 } 392 adapter->tx_ring_count = new_tx_count; 393 394 for (j = 0; j < adapter->num_xdp_queues; i++, j++) { 395 ixgbevf_free_tx_resources(adapter->xdp_ring[j]); 396 *adapter->xdp_ring[j] = tx_ring[i]; 397 } 398 adapter->xdp_ring_count = new_tx_count; 399 400 vfree(tx_ring); 401 tx_ring = NULL; 402 } 403 404 /* Rx */ 405 if (rx_ring) { 406 for (i = 0; i < adapter->num_rx_queues; i++) { 407 ixgbevf_free_rx_resources(adapter->rx_ring[i]); 408 *adapter->rx_ring[i] = rx_ring[i]; 409 } 410 adapter->rx_ring_count = new_rx_count; 411 412 vfree(rx_ring); 413 rx_ring = NULL; 414 } 415 416 /* restore interface using new values */ 417 ixgbevf_up(adapter); 418 419 clear_reset: 420 /* free Tx resources if Rx error is encountered */ 421 if (tx_ring) { 422 for (i = 0; 423 i < adapter->num_tx_queues + adapter->num_xdp_queues; i++) 424 ixgbevf_free_tx_resources(&tx_ring[i]); 425 vfree(tx_ring); 426 } 427 428 clear_bit(__IXGBEVF_RESETTING, &adapter->state); 429 return err; 430 } 431 432 static int ixgbevf_get_sset_count(struct net_device *netdev, int stringset) 433 { 434 switch (stringset) { 435 case ETH_SS_TEST: 436 return IXGBEVF_TEST_LEN; 437 case ETH_SS_STATS: 438 return IXGBEVF_STATS_LEN; 439 case ETH_SS_PRIV_FLAGS: 440 return IXGBEVF_PRIV_FLAGS_STR_LEN; 441 default: 442 return -EINVAL; 443 } 444 } 445 446 static void ixgbevf_get_ethtool_stats(struct net_device *netdev, 447 struct ethtool_stats *stats, u64 *data) 448 { 449 struct ixgbevf_adapter *adapter = netdev_priv(netdev); 450 struct rtnl_link_stats64 temp; 451 const struct rtnl_link_stats64 *net_stats; 452 unsigned int start; 453 struct ixgbevf_ring *ring; 454 int i, j; 455 char *p; 456 457 ixgbevf_update_stats(adapter); 458 net_stats = dev_get_stats(netdev, &temp); 459 for (i = 0; i < IXGBEVF_GLOBAL_STATS_LEN; i++) { 460 switch (ixgbevf_gstrings_stats[i].type) { 461 case NETDEV_STATS: 462 p = (char *)net_stats + 463 ixgbevf_gstrings_stats[i].stat_offset; 464 break; 465 case IXGBEVF_STATS: 466 p = (char *)adapter + 467 ixgbevf_gstrings_stats[i].stat_offset; 468 break; 469 default: 470 data[i] = 0; 471 continue; 472 } 473 474 data[i] = (ixgbevf_gstrings_stats[i].sizeof_stat == 475 sizeof(u64)) ? *(u64 *)p : *(u32 *)p; 476 } 477 478 /* populate Tx queue data */ 479 for (j = 0; j < adapter->num_tx_queues; j++) { 480 ring = adapter->tx_ring[j]; 481 if (!ring) { 482 data[i++] = 0; 483 data[i++] = 0; 484 continue; 485 } 486 487 do { 488 start = u64_stats_fetch_begin_irq(&ring->syncp); 489 data[i] = ring->stats.packets; 490 data[i + 1] = ring->stats.bytes; 491 } while (u64_stats_fetch_retry_irq(&ring->syncp, start)); 492 i += 2; 493 } 494 495 /* populate XDP queue data */ 496 for (j = 0; j < adapter->num_xdp_queues; j++) { 497 ring = adapter->xdp_ring[j]; 498 if (!ring) { 499 data[i++] = 0; 500 data[i++] = 0; 501 continue; 502 } 503 504 do { 505 start = u64_stats_fetch_begin_irq(&ring->syncp); 506 data[i] = ring->stats.packets; 507 data[i + 1] = ring->stats.bytes; 508 } while (u64_stats_fetch_retry_irq(&ring->syncp, start)); 509 i += 2; 510 } 511 512 /* populate Rx queue data */ 513 for (j = 0; j < adapter->num_rx_queues; j++) { 514 ring = adapter->rx_ring[j]; 515 if (!ring) { 516 data[i++] = 0; 517 data[i++] = 0; 518 continue; 519 } 520 521 do { 522 start = u64_stats_fetch_begin_irq(&ring->syncp); 523 data[i] = ring->stats.packets; 524 data[i + 1] = ring->stats.bytes; 525 } while (u64_stats_fetch_retry_irq(&ring->syncp, start)); 526 i += 2; 527 } 528 } 529 530 static void ixgbevf_get_strings(struct net_device *netdev, u32 stringset, 531 u8 *data) 532 { 533 struct ixgbevf_adapter *adapter = netdev_priv(netdev); 534 char *p = (char *)data; 535 int i; 536 537 switch (stringset) { 538 case ETH_SS_TEST: 539 memcpy(data, *ixgbe_gstrings_test, 540 IXGBEVF_TEST_LEN * ETH_GSTRING_LEN); 541 break; 542 case ETH_SS_STATS: 543 for (i = 0; i < IXGBEVF_GLOBAL_STATS_LEN; i++) { 544 memcpy(p, ixgbevf_gstrings_stats[i].stat_string, 545 ETH_GSTRING_LEN); 546 p += ETH_GSTRING_LEN; 547 } 548 549 for (i = 0; i < adapter->num_tx_queues; i++) { 550 sprintf(p, "tx_queue_%u_packets", i); 551 p += ETH_GSTRING_LEN; 552 sprintf(p, "tx_queue_%u_bytes", i); 553 p += ETH_GSTRING_LEN; 554 } 555 for (i = 0; i < adapter->num_xdp_queues; i++) { 556 sprintf(p, "xdp_queue_%u_packets", i); 557 p += ETH_GSTRING_LEN; 558 sprintf(p, "xdp_queue_%u_bytes", i); 559 p += ETH_GSTRING_LEN; 560 } 561 for (i = 0; i < adapter->num_rx_queues; i++) { 562 sprintf(p, "rx_queue_%u_packets", i); 563 p += ETH_GSTRING_LEN; 564 sprintf(p, "rx_queue_%u_bytes", i); 565 p += ETH_GSTRING_LEN; 566 } 567 break; 568 case ETH_SS_PRIV_FLAGS: 569 memcpy(data, ixgbevf_priv_flags_strings, 570 IXGBEVF_PRIV_FLAGS_STR_LEN * ETH_GSTRING_LEN); 571 break; 572 } 573 } 574 575 static int ixgbevf_link_test(struct ixgbevf_adapter *adapter, u64 *data) 576 { 577 struct ixgbe_hw *hw = &adapter->hw; 578 bool link_up; 579 u32 link_speed = 0; 580 *data = 0; 581 582 hw->mac.ops.check_link(hw, &link_speed, &link_up, true); 583 if (!link_up) 584 *data = 1; 585 586 return *data; 587 } 588 589 /* ethtool register test data */ 590 struct ixgbevf_reg_test { 591 u16 reg; 592 u8 array_len; 593 u8 test_type; 594 u32 mask; 595 u32 write; 596 }; 597 598 /* In the hardware, registers are laid out either singly, in arrays 599 * spaced 0x40 bytes apart, or in contiguous tables. We assume 600 * most tests take place on arrays or single registers (handled 601 * as a single-element array) and special-case the tables. 602 * Table tests are always pattern tests. 603 * 604 * We also make provision for some required setup steps by specifying 605 * registers to be written without any read-back testing. 606 */ 607 608 #define PATTERN_TEST 1 609 #define SET_READ_TEST 2 610 #define WRITE_NO_TEST 3 611 #define TABLE32_TEST 4 612 #define TABLE64_TEST_LO 5 613 #define TABLE64_TEST_HI 6 614 615 /* default VF register test */ 616 static const struct ixgbevf_reg_test reg_test_vf[] = { 617 { IXGBE_VFRDBAL(0), 2, PATTERN_TEST, 0xFFFFFF80, 0xFFFFFF80 }, 618 { IXGBE_VFRDBAH(0), 2, PATTERN_TEST, 0xFFFFFFFF, 0xFFFFFFFF }, 619 { IXGBE_VFRDLEN(0), 2, PATTERN_TEST, 0x000FFF80, 0x000FFFFF }, 620 { IXGBE_VFRXDCTL(0), 2, WRITE_NO_TEST, 0, IXGBE_RXDCTL_ENABLE }, 621 { IXGBE_VFRDT(0), 2, PATTERN_TEST, 0x0000FFFF, 0x0000FFFF }, 622 { IXGBE_VFRXDCTL(0), 2, WRITE_NO_TEST, 0, 0 }, 623 { IXGBE_VFTDBAL(0), 2, PATTERN_TEST, 0xFFFFFF80, 0xFFFFFFFF }, 624 { IXGBE_VFTDBAH(0), 2, PATTERN_TEST, 0xFFFFFFFF, 0xFFFFFFFF }, 625 { IXGBE_VFTDLEN(0), 2, PATTERN_TEST, 0x000FFF80, 0x000FFF80 }, 626 { .reg = 0 } 627 }; 628 629 static const u32 register_test_patterns[] = { 630 0x5A5A5A5A, 0xA5A5A5A5, 0x00000000, 0xFFFFFFFF 631 }; 632 633 static bool reg_pattern_test(struct ixgbevf_adapter *adapter, u64 *data, 634 int reg, u32 mask, u32 write) 635 { 636 u32 pat, val, before; 637 638 if (IXGBE_REMOVED(adapter->hw.hw_addr)) { 639 *data = 1; 640 return true; 641 } 642 for (pat = 0; pat < ARRAY_SIZE(register_test_patterns); pat++) { 643 before = ixgbevf_read_reg(&adapter->hw, reg); 644 ixgbe_write_reg(&adapter->hw, reg, 645 register_test_patterns[pat] & write); 646 val = ixgbevf_read_reg(&adapter->hw, reg); 647 if (val != (register_test_patterns[pat] & write & mask)) { 648 hw_dbg(&adapter->hw, 649 "pattern test reg %04X failed: got 0x%08X expected 0x%08X\n", 650 reg, val, 651 register_test_patterns[pat] & write & mask); 652 *data = reg; 653 ixgbe_write_reg(&adapter->hw, reg, before); 654 return true; 655 } 656 ixgbe_write_reg(&adapter->hw, reg, before); 657 } 658 return false; 659 } 660 661 static bool reg_set_and_check(struct ixgbevf_adapter *adapter, u64 *data, 662 int reg, u32 mask, u32 write) 663 { 664 u32 val, before; 665 666 if (IXGBE_REMOVED(adapter->hw.hw_addr)) { 667 *data = 1; 668 return true; 669 } 670 before = ixgbevf_read_reg(&adapter->hw, reg); 671 ixgbe_write_reg(&adapter->hw, reg, write & mask); 672 val = ixgbevf_read_reg(&adapter->hw, reg); 673 if ((write & mask) != (val & mask)) { 674 pr_err("set/check reg %04X test failed: got 0x%08X expected 0x%08X\n", 675 reg, (val & mask), write & mask); 676 *data = reg; 677 ixgbe_write_reg(&adapter->hw, reg, before); 678 return true; 679 } 680 ixgbe_write_reg(&adapter->hw, reg, before); 681 return false; 682 } 683 684 static int ixgbevf_reg_test(struct ixgbevf_adapter *adapter, u64 *data) 685 { 686 const struct ixgbevf_reg_test *test; 687 u32 i; 688 689 if (IXGBE_REMOVED(adapter->hw.hw_addr)) { 690 dev_err(&adapter->pdev->dev, 691 "Adapter removed - register test blocked\n"); 692 *data = 1; 693 return 1; 694 } 695 test = reg_test_vf; 696 697 /* Perform the register test, looping through the test table 698 * until we either fail or reach the null entry. 699 */ 700 while (test->reg) { 701 for (i = 0; i < test->array_len; i++) { 702 bool b = false; 703 704 switch (test->test_type) { 705 case PATTERN_TEST: 706 b = reg_pattern_test(adapter, data, 707 test->reg + (i * 0x40), 708 test->mask, 709 test->write); 710 break; 711 case SET_READ_TEST: 712 b = reg_set_and_check(adapter, data, 713 test->reg + (i * 0x40), 714 test->mask, 715 test->write); 716 break; 717 case WRITE_NO_TEST: 718 ixgbe_write_reg(&adapter->hw, 719 test->reg + (i * 0x40), 720 test->write); 721 break; 722 case TABLE32_TEST: 723 b = reg_pattern_test(adapter, data, 724 test->reg + (i * 4), 725 test->mask, 726 test->write); 727 break; 728 case TABLE64_TEST_LO: 729 b = reg_pattern_test(adapter, data, 730 test->reg + (i * 8), 731 test->mask, 732 test->write); 733 break; 734 case TABLE64_TEST_HI: 735 b = reg_pattern_test(adapter, data, 736 test->reg + 4 + (i * 8), 737 test->mask, 738 test->write); 739 break; 740 } 741 if (b) 742 return 1; 743 } 744 test++; 745 } 746 747 *data = 0; 748 return *data; 749 } 750 751 static void ixgbevf_diag_test(struct net_device *netdev, 752 struct ethtool_test *eth_test, u64 *data) 753 { 754 struct ixgbevf_adapter *adapter = netdev_priv(netdev); 755 bool if_running = netif_running(netdev); 756 757 if (IXGBE_REMOVED(adapter->hw.hw_addr)) { 758 dev_err(&adapter->pdev->dev, 759 "Adapter removed - test blocked\n"); 760 data[0] = 1; 761 data[1] = 1; 762 eth_test->flags |= ETH_TEST_FL_FAILED; 763 return; 764 } 765 set_bit(__IXGBEVF_TESTING, &adapter->state); 766 if (eth_test->flags == ETH_TEST_FL_OFFLINE) { 767 /* Offline tests */ 768 769 hw_dbg(&adapter->hw, "offline testing starting\n"); 770 771 /* Link test performed before hardware reset so autoneg doesn't 772 * interfere with test result 773 */ 774 if (ixgbevf_link_test(adapter, &data[1])) 775 eth_test->flags |= ETH_TEST_FL_FAILED; 776 777 if (if_running) 778 /* indicate we're in test mode */ 779 ixgbevf_close(netdev); 780 else 781 ixgbevf_reset(adapter); 782 783 hw_dbg(&adapter->hw, "register testing starting\n"); 784 if (ixgbevf_reg_test(adapter, &data[0])) 785 eth_test->flags |= ETH_TEST_FL_FAILED; 786 787 ixgbevf_reset(adapter); 788 789 clear_bit(__IXGBEVF_TESTING, &adapter->state); 790 if (if_running) 791 ixgbevf_open(netdev); 792 } else { 793 hw_dbg(&adapter->hw, "online testing starting\n"); 794 /* Online tests */ 795 if (ixgbevf_link_test(adapter, &data[1])) 796 eth_test->flags |= ETH_TEST_FL_FAILED; 797 798 /* Online tests aren't run; pass by default */ 799 data[0] = 0; 800 801 clear_bit(__IXGBEVF_TESTING, &adapter->state); 802 } 803 msleep_interruptible(4 * 1000); 804 } 805 806 static int ixgbevf_nway_reset(struct net_device *netdev) 807 { 808 struct ixgbevf_adapter *adapter = netdev_priv(netdev); 809 810 if (netif_running(netdev)) 811 ixgbevf_reinit_locked(adapter); 812 813 return 0; 814 } 815 816 static int ixgbevf_get_coalesce(struct net_device *netdev, 817 struct ethtool_coalesce *ec) 818 { 819 struct ixgbevf_adapter *adapter = netdev_priv(netdev); 820 821 /* only valid if in constant ITR mode */ 822 if (adapter->rx_itr_setting <= 1) 823 ec->rx_coalesce_usecs = adapter->rx_itr_setting; 824 else 825 ec->rx_coalesce_usecs = adapter->rx_itr_setting >> 2; 826 827 /* if in mixed Tx/Rx queues per vector mode, report only Rx settings */ 828 if (adapter->q_vector[0]->tx.count && adapter->q_vector[0]->rx.count) 829 return 0; 830 831 /* only valid if in constant ITR mode */ 832 if (adapter->tx_itr_setting <= 1) 833 ec->tx_coalesce_usecs = adapter->tx_itr_setting; 834 else 835 ec->tx_coalesce_usecs = adapter->tx_itr_setting >> 2; 836 837 return 0; 838 } 839 840 static int ixgbevf_set_coalesce(struct net_device *netdev, 841 struct ethtool_coalesce *ec) 842 { 843 struct ixgbevf_adapter *adapter = netdev_priv(netdev); 844 struct ixgbevf_q_vector *q_vector; 845 int num_vectors, i; 846 u16 tx_itr_param, rx_itr_param; 847 848 /* don't accept Tx specific changes if we've got mixed RxTx vectors */ 849 if (adapter->q_vector[0]->tx.count && 850 adapter->q_vector[0]->rx.count && ec->tx_coalesce_usecs) 851 return -EINVAL; 852 853 if ((ec->rx_coalesce_usecs > (IXGBE_MAX_EITR >> 2)) || 854 (ec->tx_coalesce_usecs > (IXGBE_MAX_EITR >> 2))) 855 return -EINVAL; 856 857 if (ec->rx_coalesce_usecs > 1) 858 adapter->rx_itr_setting = ec->rx_coalesce_usecs << 2; 859 else 860 adapter->rx_itr_setting = ec->rx_coalesce_usecs; 861 862 if (adapter->rx_itr_setting == 1) 863 rx_itr_param = IXGBE_20K_ITR; 864 else 865 rx_itr_param = adapter->rx_itr_setting; 866 867 if (ec->tx_coalesce_usecs > 1) 868 adapter->tx_itr_setting = ec->tx_coalesce_usecs << 2; 869 else 870 adapter->tx_itr_setting = ec->tx_coalesce_usecs; 871 872 if (adapter->tx_itr_setting == 1) 873 tx_itr_param = IXGBE_12K_ITR; 874 else 875 tx_itr_param = adapter->tx_itr_setting; 876 877 num_vectors = adapter->num_msix_vectors - NON_Q_VECTORS; 878 879 for (i = 0; i < num_vectors; i++) { 880 q_vector = adapter->q_vector[i]; 881 if (q_vector->tx.count && !q_vector->rx.count) 882 /* Tx only */ 883 q_vector->itr = tx_itr_param; 884 else 885 /* Rx only or mixed */ 886 q_vector->itr = rx_itr_param; 887 ixgbevf_write_eitr(q_vector); 888 } 889 890 return 0; 891 } 892 893 static int ixgbevf_get_rxnfc(struct net_device *dev, struct ethtool_rxnfc *info, 894 u32 *rules __always_unused) 895 { 896 struct ixgbevf_adapter *adapter = netdev_priv(dev); 897 898 switch (info->cmd) { 899 case ETHTOOL_GRXRINGS: 900 info->data = adapter->num_rx_queues; 901 return 0; 902 default: 903 hw_dbg(&adapter->hw, "Command parameters not supported\n"); 904 return -EOPNOTSUPP; 905 } 906 } 907 908 static u32 ixgbevf_get_rxfh_indir_size(struct net_device *netdev) 909 { 910 struct ixgbevf_adapter *adapter = netdev_priv(netdev); 911 912 if (adapter->hw.mac.type >= ixgbe_mac_X550_vf) 913 return IXGBEVF_X550_VFRETA_SIZE; 914 915 return IXGBEVF_82599_RETA_SIZE; 916 } 917 918 static u32 ixgbevf_get_rxfh_key_size(struct net_device *netdev) 919 { 920 return IXGBEVF_RSS_HASH_KEY_SIZE; 921 } 922 923 static int ixgbevf_get_rxfh(struct net_device *netdev, u32 *indir, u8 *key, 924 u8 *hfunc) 925 { 926 struct ixgbevf_adapter *adapter = netdev_priv(netdev); 927 int err = 0; 928 929 if (hfunc) 930 *hfunc = ETH_RSS_HASH_TOP; 931 932 if (adapter->hw.mac.type >= ixgbe_mac_X550_vf) { 933 if (key) 934 memcpy(key, adapter->rss_key, 935 ixgbevf_get_rxfh_key_size(netdev)); 936 937 if (indir) { 938 int i; 939 940 for (i = 0; i < IXGBEVF_X550_VFRETA_SIZE; i++) 941 indir[i] = adapter->rss_indir_tbl[i]; 942 } 943 } else { 944 /* If neither indirection table nor hash key was requested 945 * - just return a success avoiding taking any locks. 946 */ 947 if (!indir && !key) 948 return 0; 949 950 spin_lock_bh(&adapter->mbx_lock); 951 if (indir) 952 err = ixgbevf_get_reta_locked(&adapter->hw, indir, 953 adapter->num_rx_queues); 954 955 if (!err && key) 956 err = ixgbevf_get_rss_key_locked(&adapter->hw, key); 957 958 spin_unlock_bh(&adapter->mbx_lock); 959 } 960 961 return err; 962 } 963 964 static u32 ixgbevf_get_priv_flags(struct net_device *netdev) 965 { 966 struct ixgbevf_adapter *adapter = netdev_priv(netdev); 967 u32 priv_flags = 0; 968 969 if (adapter->flags & IXGBEVF_FLAGS_LEGACY_RX) 970 priv_flags |= IXGBEVF_PRIV_FLAGS_LEGACY_RX; 971 972 return priv_flags; 973 } 974 975 static int ixgbevf_set_priv_flags(struct net_device *netdev, u32 priv_flags) 976 { 977 struct ixgbevf_adapter *adapter = netdev_priv(netdev); 978 unsigned int flags = adapter->flags; 979 980 flags &= ~IXGBEVF_FLAGS_LEGACY_RX; 981 if (priv_flags & IXGBEVF_PRIV_FLAGS_LEGACY_RX) 982 flags |= IXGBEVF_FLAGS_LEGACY_RX; 983 984 if (flags != adapter->flags) { 985 adapter->flags = flags; 986 987 /* reset interface to repopulate queues */ 988 if (netif_running(netdev)) 989 ixgbevf_reinit_locked(adapter); 990 } 991 992 return 0; 993 } 994 995 static const struct ethtool_ops ixgbevf_ethtool_ops = { 996 .get_drvinfo = ixgbevf_get_drvinfo, 997 .get_regs_len = ixgbevf_get_regs_len, 998 .get_regs = ixgbevf_get_regs, 999 .nway_reset = ixgbevf_nway_reset, 1000 .get_link = ethtool_op_get_link, 1001 .get_ringparam = ixgbevf_get_ringparam, 1002 .set_ringparam = ixgbevf_set_ringparam, 1003 .get_msglevel = ixgbevf_get_msglevel, 1004 .set_msglevel = ixgbevf_set_msglevel, 1005 .self_test = ixgbevf_diag_test, 1006 .get_sset_count = ixgbevf_get_sset_count, 1007 .get_strings = ixgbevf_get_strings, 1008 .get_ethtool_stats = ixgbevf_get_ethtool_stats, 1009 .get_coalesce = ixgbevf_get_coalesce, 1010 .set_coalesce = ixgbevf_set_coalesce, 1011 .get_rxnfc = ixgbevf_get_rxnfc, 1012 .get_rxfh_indir_size = ixgbevf_get_rxfh_indir_size, 1013 .get_rxfh_key_size = ixgbevf_get_rxfh_key_size, 1014 .get_rxfh = ixgbevf_get_rxfh, 1015 .get_link_ksettings = ixgbevf_get_link_ksettings, 1016 .get_priv_flags = ixgbevf_get_priv_flags, 1017 .set_priv_flags = ixgbevf_set_priv_flags, 1018 }; 1019 1020 void ixgbevf_set_ethtool_ops(struct net_device *netdev) 1021 { 1022 netdev->ethtool_ops = &ixgbevf_ethtool_ops; 1023 } 1024