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