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