/drivers/net/ixgbevf/ethtool.c
C | 742 lines | 585 code | 92 blank | 65 comment | 66 complexity | 0269354e8d3067362ef1faf10b519cd7 MD5 | raw file
Possible License(s): GPL-2.0, LGPL-2.0, AGPL-1.0
1/******************************************************************************* 2 3 Intel 82599 Virtual Function driver 4 Copyright(c) 1999 - 2009 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, write to the Free Software Foundation, Inc., 17 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA. 18 19 The full GNU General Public License is included in this distribution in 20 the file called "COPYING". 21 22 Contact Information: 23 e1000-devel Mailing List <e1000-devel@lists.sourceforge.net> 24 Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497 25 26*******************************************************************************/ 27 28/* ethtool support for ixgbevf */ 29 30#include <linux/types.h> 31#include <linux/module.h> 32#include <linux/slab.h> 33#include <linux/pci.h> 34#include <linux/netdevice.h> 35#include <linux/ethtool.h> 36#include <linux/vmalloc.h> 37#include <linux/if_vlan.h> 38#include <linux/uaccess.h> 39 40#include "ixgbevf.h" 41 42#define IXGBE_ALL_RAR_ENTRIES 16 43 44#ifdef ETHTOOL_GSTATS 45struct ixgbe_stats { 46 char stat_string[ETH_GSTRING_LEN]; 47 int sizeof_stat; 48 int stat_offset; 49 int base_stat_offset; 50 int saved_reset_offset; 51}; 52 53#define IXGBEVF_STAT(m, b, r) sizeof(((struct ixgbevf_adapter *)0)->m), \ 54 offsetof(struct ixgbevf_adapter, m), \ 55 offsetof(struct ixgbevf_adapter, b), \ 56 offsetof(struct ixgbevf_adapter, r) 57static struct ixgbe_stats ixgbe_gstrings_stats[] = { 58 {"rx_packets", IXGBEVF_STAT(stats.vfgprc, stats.base_vfgprc, 59 stats.saved_reset_vfgprc)}, 60 {"tx_packets", IXGBEVF_STAT(stats.vfgptc, stats.base_vfgptc, 61 stats.saved_reset_vfgptc)}, 62 {"rx_bytes", IXGBEVF_STAT(stats.vfgorc, stats.base_vfgorc, 63 stats.saved_reset_vfgorc)}, 64 {"tx_bytes", IXGBEVF_STAT(stats.vfgotc, stats.base_vfgotc, 65 stats.saved_reset_vfgotc)}, 66 {"tx_busy", IXGBEVF_STAT(tx_busy, zero_base, zero_base)}, 67 {"multicast", IXGBEVF_STAT(stats.vfmprc, stats.base_vfmprc, 68 stats.saved_reset_vfmprc)}, 69 {"rx_csum_offload_good", IXGBEVF_STAT(hw_csum_rx_good, zero_base, 70 zero_base)}, 71 {"rx_csum_offload_errors", IXGBEVF_STAT(hw_csum_rx_error, zero_base, 72 zero_base)}, 73 {"tx_csum_offload_ctxt", IXGBEVF_STAT(hw_csum_tx_good, zero_base, 74 zero_base)}, 75 {"rx_header_split", IXGBEVF_STAT(rx_hdr_split, zero_base, zero_base)}, 76}; 77 78#define IXGBE_QUEUE_STATS_LEN 0 79#define IXGBE_GLOBAL_STATS_LEN ARRAY_SIZE(ixgbe_gstrings_stats) 80 81#define IXGBEVF_STATS_LEN (IXGBE_GLOBAL_STATS_LEN + IXGBE_QUEUE_STATS_LEN) 82#endif /* ETHTOOL_GSTATS */ 83#ifdef ETHTOOL_TEST 84static const char ixgbe_gstrings_test[][ETH_GSTRING_LEN] = { 85 "Register test (offline)", 86 "Link test (on/offline)" 87}; 88#define IXGBE_TEST_LEN (sizeof(ixgbe_gstrings_test) / ETH_GSTRING_LEN) 89#endif /* ETHTOOL_TEST */ 90 91static int ixgbevf_get_settings(struct net_device *netdev, 92 struct ethtool_cmd *ecmd) 93{ 94 struct ixgbevf_adapter *adapter = netdev_priv(netdev); 95 struct ixgbe_hw *hw = &adapter->hw; 96 u32 link_speed = 0; 97 bool link_up; 98 99 ecmd->supported = SUPPORTED_10000baseT_Full; 100 ecmd->autoneg = AUTONEG_DISABLE; 101 ecmd->transceiver = XCVR_DUMMY1; 102 ecmd->port = -1; 103 104 hw->mac.ops.check_link(hw, &link_speed, &link_up, false); 105 106 if (link_up) { 107 ethtool_cmd_speed_set( 108 ecmd, 109 (link_speed == IXGBE_LINK_SPEED_10GB_FULL) ? 110 SPEED_10000 : SPEED_1000); 111 ecmd->duplex = DUPLEX_FULL; 112 } else { 113 ethtool_cmd_speed_set(ecmd, -1); 114 ecmd->duplex = -1; 115 } 116 117 return 0; 118} 119 120static u32 ixgbevf_get_rx_csum(struct net_device *netdev) 121{ 122 struct ixgbevf_adapter *adapter = netdev_priv(netdev); 123 return adapter->flags & IXGBE_FLAG_RX_CSUM_ENABLED; 124} 125 126static int ixgbevf_set_rx_csum(struct net_device *netdev, u32 data) 127{ 128 struct ixgbevf_adapter *adapter = netdev_priv(netdev); 129 if (data) 130 adapter->flags |= IXGBE_FLAG_RX_CSUM_ENABLED; 131 else 132 adapter->flags &= ~IXGBE_FLAG_RX_CSUM_ENABLED; 133 134 if (netif_running(netdev)) { 135 if (!adapter->dev_closed) 136 ixgbevf_reinit_locked(adapter); 137 } else { 138 ixgbevf_reset(adapter); 139 } 140 141 return 0; 142} 143 144static int ixgbevf_set_tso(struct net_device *netdev, u32 data) 145{ 146 if (data) { 147 netdev->features |= NETIF_F_TSO; 148 netdev->features |= NETIF_F_TSO6; 149 } else { 150 netif_tx_stop_all_queues(netdev); 151 netdev->features &= ~NETIF_F_TSO; 152 netdev->features &= ~NETIF_F_TSO6; 153 netif_tx_start_all_queues(netdev); 154 } 155 return 0; 156} 157 158static u32 ixgbevf_get_msglevel(struct net_device *netdev) 159{ 160 struct ixgbevf_adapter *adapter = netdev_priv(netdev); 161 return adapter->msg_enable; 162} 163 164static void ixgbevf_set_msglevel(struct net_device *netdev, u32 data) 165{ 166 struct ixgbevf_adapter *adapter = netdev_priv(netdev); 167 adapter->msg_enable = data; 168} 169 170#define IXGBE_GET_STAT(_A_, _R_) (_A_->stats._R_) 171 172static char *ixgbevf_reg_names[] = { 173 "IXGBE_VFCTRL", 174 "IXGBE_VFSTATUS", 175 "IXGBE_VFLINKS", 176 "IXGBE_VFRXMEMWRAP", 177 "IXGBE_VFFRTIMER", 178 "IXGBE_VTEICR", 179 "IXGBE_VTEICS", 180 "IXGBE_VTEIMS", 181 "IXGBE_VTEIMC", 182 "IXGBE_VTEIAC", 183 "IXGBE_VTEIAM", 184 "IXGBE_VTEITR", 185 "IXGBE_VTIVAR", 186 "IXGBE_VTIVAR_MISC", 187 "IXGBE_VFRDBAL0", 188 "IXGBE_VFRDBAL1", 189 "IXGBE_VFRDBAH0", 190 "IXGBE_VFRDBAH1", 191 "IXGBE_VFRDLEN0", 192 "IXGBE_VFRDLEN1", 193 "IXGBE_VFRDH0", 194 "IXGBE_VFRDH1", 195 "IXGBE_VFRDT0", 196 "IXGBE_VFRDT1", 197 "IXGBE_VFRXDCTL0", 198 "IXGBE_VFRXDCTL1", 199 "IXGBE_VFSRRCTL0", 200 "IXGBE_VFSRRCTL1", 201 "IXGBE_VFPSRTYPE", 202 "IXGBE_VFTDBAL0", 203 "IXGBE_VFTDBAL1", 204 "IXGBE_VFTDBAH0", 205 "IXGBE_VFTDBAH1", 206 "IXGBE_VFTDLEN0", 207 "IXGBE_VFTDLEN1", 208 "IXGBE_VFTDH0", 209 "IXGBE_VFTDH1", 210 "IXGBE_VFTDT0", 211 "IXGBE_VFTDT1", 212 "IXGBE_VFTXDCTL0", 213 "IXGBE_VFTXDCTL1", 214 "IXGBE_VFTDWBAL0", 215 "IXGBE_VFTDWBAL1", 216 "IXGBE_VFTDWBAH0", 217 "IXGBE_VFTDWBAH1" 218}; 219 220 221static int ixgbevf_get_regs_len(struct net_device *netdev) 222{ 223 return (ARRAY_SIZE(ixgbevf_reg_names)) * sizeof(u32); 224} 225 226static void ixgbevf_get_regs(struct net_device *netdev, 227 struct ethtool_regs *regs, 228 void *p) 229{ 230 struct ixgbevf_adapter *adapter = netdev_priv(netdev); 231 struct ixgbe_hw *hw = &adapter->hw; 232 u32 *regs_buff = p; 233 u32 regs_len = ixgbevf_get_regs_len(netdev); 234 u8 i; 235 236 memset(p, 0, regs_len); 237 238 regs->version = (1 << 24) | hw->revision_id << 16 | hw->device_id; 239 240 /* General Registers */ 241 regs_buff[0] = IXGBE_READ_REG(hw, IXGBE_VFCTRL); 242 regs_buff[1] = IXGBE_READ_REG(hw, IXGBE_VFSTATUS); 243 regs_buff[2] = IXGBE_READ_REG(hw, IXGBE_VFLINKS); 244 regs_buff[3] = IXGBE_READ_REG(hw, IXGBE_VFRXMEMWRAP); 245 regs_buff[4] = IXGBE_READ_REG(hw, IXGBE_VFFRTIMER); 246 247 /* Interrupt */ 248 /* don't read EICR because it can clear interrupt causes, instead 249 * read EICS which is a shadow but doesn't clear EICR */ 250 regs_buff[5] = IXGBE_READ_REG(hw, IXGBE_VTEICS); 251 regs_buff[6] = IXGBE_READ_REG(hw, IXGBE_VTEICS); 252 regs_buff[7] = IXGBE_READ_REG(hw, IXGBE_VTEIMS); 253 regs_buff[8] = IXGBE_READ_REG(hw, IXGBE_VTEIMC); 254 regs_buff[9] = IXGBE_READ_REG(hw, IXGBE_VTEIAC); 255 regs_buff[10] = IXGBE_READ_REG(hw, IXGBE_VTEIAM); 256 regs_buff[11] = IXGBE_READ_REG(hw, IXGBE_VTEITR(0)); 257 regs_buff[12] = IXGBE_READ_REG(hw, IXGBE_VTIVAR(0)); 258 regs_buff[13] = IXGBE_READ_REG(hw, IXGBE_VTIVAR_MISC); 259 260 /* Receive DMA */ 261 for (i = 0; i < 2; i++) 262 regs_buff[14 + i] = IXGBE_READ_REG(hw, IXGBE_VFRDBAL(i)); 263 for (i = 0; i < 2; i++) 264 regs_buff[16 + i] = IXGBE_READ_REG(hw, IXGBE_VFRDBAH(i)); 265 for (i = 0; i < 2; i++) 266 regs_buff[18 + i] = IXGBE_READ_REG(hw, IXGBE_VFRDLEN(i)); 267 for (i = 0; i < 2; i++) 268 regs_buff[20 + i] = IXGBE_READ_REG(hw, IXGBE_VFRDH(i)); 269 for (i = 0; i < 2; i++) 270 regs_buff[22 + i] = IXGBE_READ_REG(hw, IXGBE_VFRDT(i)); 271 for (i = 0; i < 2; i++) 272 regs_buff[24 + i] = IXGBE_READ_REG(hw, IXGBE_VFRXDCTL(i)); 273 for (i = 0; i < 2; i++) 274 regs_buff[26 + i] = IXGBE_READ_REG(hw, IXGBE_VFSRRCTL(i)); 275 276 /* Receive */ 277 regs_buff[28] = IXGBE_READ_REG(hw, IXGBE_VFPSRTYPE); 278 279 /* Transmit */ 280 for (i = 0; i < 2; i++) 281 regs_buff[29 + i] = IXGBE_READ_REG(hw, IXGBE_VFTDBAL(i)); 282 for (i = 0; i < 2; i++) 283 regs_buff[31 + i] = IXGBE_READ_REG(hw, IXGBE_VFTDBAH(i)); 284 for (i = 0; i < 2; i++) 285 regs_buff[33 + i] = IXGBE_READ_REG(hw, IXGBE_VFTDLEN(i)); 286 for (i = 0; i < 2; i++) 287 regs_buff[35 + i] = IXGBE_READ_REG(hw, IXGBE_VFTDH(i)); 288 for (i = 0; i < 2; i++) 289 regs_buff[37 + i] = IXGBE_READ_REG(hw, IXGBE_VFTDT(i)); 290 for (i = 0; i < 2; i++) 291 regs_buff[39 + i] = IXGBE_READ_REG(hw, IXGBE_VFTXDCTL(i)); 292 for (i = 0; i < 2; i++) 293 regs_buff[41 + i] = IXGBE_READ_REG(hw, IXGBE_VFTDWBAL(i)); 294 for (i = 0; i < 2; i++) 295 regs_buff[43 + i] = IXGBE_READ_REG(hw, IXGBE_VFTDWBAH(i)); 296 297 for (i = 0; i < ARRAY_SIZE(ixgbevf_reg_names); i++) 298 hw_dbg(hw, "%s\t%8.8x\n", ixgbevf_reg_names[i], regs_buff[i]); 299} 300 301static void ixgbevf_get_drvinfo(struct net_device *netdev, 302 struct ethtool_drvinfo *drvinfo) 303{ 304 struct ixgbevf_adapter *adapter = netdev_priv(netdev); 305 306 strlcpy(drvinfo->driver, ixgbevf_driver_name, 32); 307 strlcpy(drvinfo->version, ixgbevf_driver_version, 32); 308 309 strlcpy(drvinfo->fw_version, "N/A", 4); 310 strlcpy(drvinfo->bus_info, pci_name(adapter->pdev), 32); 311} 312 313static void ixgbevf_get_ringparam(struct net_device *netdev, 314 struct ethtool_ringparam *ring) 315{ 316 struct ixgbevf_adapter *adapter = netdev_priv(netdev); 317 struct ixgbevf_ring *tx_ring = adapter->tx_ring; 318 struct ixgbevf_ring *rx_ring = adapter->rx_ring; 319 320 ring->rx_max_pending = IXGBEVF_MAX_RXD; 321 ring->tx_max_pending = IXGBEVF_MAX_TXD; 322 ring->rx_mini_max_pending = 0; 323 ring->rx_jumbo_max_pending = 0; 324 ring->rx_pending = rx_ring->count; 325 ring->tx_pending = tx_ring->count; 326 ring->rx_mini_pending = 0; 327 ring->rx_jumbo_pending = 0; 328} 329 330static int ixgbevf_set_ringparam(struct net_device *netdev, 331 struct ethtool_ringparam *ring) 332{ 333 struct ixgbevf_adapter *adapter = netdev_priv(netdev); 334 struct ixgbevf_ring *tx_ring = NULL, *rx_ring = NULL; 335 int i, err = 0; 336 u32 new_rx_count, new_tx_count; 337 338 if ((ring->rx_mini_pending) || (ring->rx_jumbo_pending)) 339 return -EINVAL; 340 341 new_rx_count = max(ring->rx_pending, (u32)IXGBEVF_MIN_RXD); 342 new_rx_count = min(new_rx_count, (u32)IXGBEVF_MAX_RXD); 343 new_rx_count = ALIGN(new_rx_count, IXGBE_REQ_RX_DESCRIPTOR_MULTIPLE); 344 345 new_tx_count = max(ring->tx_pending, (u32)IXGBEVF_MIN_TXD); 346 new_tx_count = min(new_tx_count, (u32)IXGBEVF_MAX_TXD); 347 new_tx_count = ALIGN(new_tx_count, IXGBE_REQ_TX_DESCRIPTOR_MULTIPLE); 348 349 if ((new_tx_count == adapter->tx_ring->count) && 350 (new_rx_count == adapter->rx_ring->count)) { 351 /* nothing to do */ 352 return 0; 353 } 354 355 while (test_and_set_bit(__IXGBEVF_RESETTING, &adapter->state)) 356 msleep(1); 357 358 /* 359 * If the adapter isn't up and running then just set the 360 * new parameters and scurry for the exits. 361 */ 362 if (!netif_running(adapter->netdev)) { 363 for (i = 0; i < adapter->num_tx_queues; i++) 364 adapter->tx_ring[i].count = new_tx_count; 365 for (i = 0; i < adapter->num_rx_queues; i++) 366 adapter->rx_ring[i].count = new_rx_count; 367 adapter->tx_ring_count = new_tx_count; 368 adapter->rx_ring_count = new_rx_count; 369 goto clear_reset; 370 } 371 372 tx_ring = kcalloc(adapter->num_tx_queues, 373 sizeof(struct ixgbevf_ring), GFP_KERNEL); 374 if (!tx_ring) { 375 err = -ENOMEM; 376 goto clear_reset; 377 } 378 379 rx_ring = kcalloc(adapter->num_rx_queues, 380 sizeof(struct ixgbevf_ring), GFP_KERNEL); 381 if (!rx_ring) { 382 err = -ENOMEM; 383 goto err_rx_setup; 384 } 385 386 ixgbevf_down(adapter); 387 388 memcpy(tx_ring, adapter->tx_ring, 389 adapter->num_tx_queues * sizeof(struct ixgbevf_ring)); 390 for (i = 0; i < adapter->num_tx_queues; i++) { 391 tx_ring[i].count = new_tx_count; 392 err = ixgbevf_setup_tx_resources(adapter, &tx_ring[i]); 393 if (err) { 394 while (i) { 395 i--; 396 ixgbevf_free_tx_resources(adapter, 397 &tx_ring[i]); 398 } 399 goto err_tx_ring_setup; 400 } 401 tx_ring[i].v_idx = adapter->tx_ring[i].v_idx; 402 } 403 404 memcpy(rx_ring, adapter->rx_ring, 405 adapter->num_rx_queues * sizeof(struct ixgbevf_ring)); 406 for (i = 0; i < adapter->num_rx_queues; i++) { 407 rx_ring[i].count = new_rx_count; 408 err = ixgbevf_setup_rx_resources(adapter, &rx_ring[i]); 409 if (err) { 410 while (i) { 411 i--; 412 ixgbevf_free_rx_resources(adapter, 413 &rx_ring[i]); 414 } 415 goto err_rx_ring_setup; 416 } 417 rx_ring[i].v_idx = adapter->rx_ring[i].v_idx; 418 } 419 420 /* 421 * Only switch to new rings if all the prior allocations 422 * and ring setups have succeeded. 423 */ 424 kfree(adapter->tx_ring); 425 adapter->tx_ring = tx_ring; 426 adapter->tx_ring_count = new_tx_count; 427 428 kfree(adapter->rx_ring); 429 adapter->rx_ring = rx_ring; 430 adapter->rx_ring_count = new_rx_count; 431 432 /* success! */ 433 ixgbevf_up(adapter); 434 435 goto clear_reset; 436 437err_rx_ring_setup: 438 for(i = 0; i < adapter->num_tx_queues; i++) 439 ixgbevf_free_tx_resources(adapter, &tx_ring[i]); 440 441err_tx_ring_setup: 442 kfree(rx_ring); 443 444err_rx_setup: 445 kfree(tx_ring); 446 447clear_reset: 448 clear_bit(__IXGBEVF_RESETTING, &adapter->state); 449 return err; 450} 451 452static int ixgbevf_get_sset_count(struct net_device *dev, int stringset) 453{ 454 switch (stringset) { 455 case ETH_SS_TEST: 456 return IXGBE_TEST_LEN; 457 case ETH_SS_STATS: 458 return IXGBE_GLOBAL_STATS_LEN; 459 default: 460 return -EINVAL; 461 } 462} 463 464static void ixgbevf_get_ethtool_stats(struct net_device *netdev, 465 struct ethtool_stats *stats, u64 *data) 466{ 467 struct ixgbevf_adapter *adapter = netdev_priv(netdev); 468 int i; 469 470 ixgbevf_update_stats(adapter); 471 for (i = 0; i < IXGBE_GLOBAL_STATS_LEN; i++) { 472 char *p = (char *)adapter + 473 ixgbe_gstrings_stats[i].stat_offset; 474 char *b = (char *)adapter + 475 ixgbe_gstrings_stats[i].base_stat_offset; 476 char *r = (char *)adapter + 477 ixgbe_gstrings_stats[i].saved_reset_offset; 478 data[i] = ((ixgbe_gstrings_stats[i].sizeof_stat == 479 sizeof(u64)) ? *(u64 *)p : *(u32 *)p) - 480 ((ixgbe_gstrings_stats[i].sizeof_stat == 481 sizeof(u64)) ? *(u64 *)b : *(u32 *)b) + 482 ((ixgbe_gstrings_stats[i].sizeof_stat == 483 sizeof(u64)) ? *(u64 *)r : *(u32 *)r); 484 } 485} 486 487static void ixgbevf_get_strings(struct net_device *netdev, u32 stringset, 488 u8 *data) 489{ 490 char *p = (char *)data; 491 int i; 492 493 switch (stringset) { 494 case ETH_SS_TEST: 495 memcpy(data, *ixgbe_gstrings_test, 496 IXGBE_TEST_LEN * ETH_GSTRING_LEN); 497 break; 498 case ETH_SS_STATS: 499 for (i = 0; i < IXGBE_GLOBAL_STATS_LEN; i++) { 500 memcpy(p, ixgbe_gstrings_stats[i].stat_string, 501 ETH_GSTRING_LEN); 502 p += ETH_GSTRING_LEN; 503 } 504 break; 505 } 506} 507 508static int ixgbevf_link_test(struct ixgbevf_adapter *adapter, u64 *data) 509{ 510 struct ixgbe_hw *hw = &adapter->hw; 511 bool link_up; 512 u32 link_speed = 0; 513 *data = 0; 514 515 hw->mac.ops.check_link(hw, &link_speed, &link_up, true); 516 if (!link_up) 517 *data = 1; 518 519 return *data; 520} 521 522/* ethtool register test data */ 523struct ixgbevf_reg_test { 524 u16 reg; 525 u8 array_len; 526 u8 test_type; 527 u32 mask; 528 u32 write; 529}; 530 531/* In the hardware, registers are laid out either singly, in arrays 532 * spaced 0x40 bytes apart, or in contiguous tables. We assume 533 * most tests take place on arrays or single registers (handled 534 * as a single-element array) and special-case the tables. 535 * Table tests are always pattern tests. 536 * 537 * We also make provision for some required setup steps by specifying 538 * registers to be written without any read-back testing. 539 */ 540 541#define PATTERN_TEST 1 542#define SET_READ_TEST 2 543#define WRITE_NO_TEST 3 544#define TABLE32_TEST 4 545#define TABLE64_TEST_LO 5 546#define TABLE64_TEST_HI 6 547 548/* default VF register test */ 549static const struct ixgbevf_reg_test reg_test_vf[] = { 550 { IXGBE_VFRDBAL(0), 2, PATTERN_TEST, 0xFFFFFF80, 0xFFFFFF80 }, 551 { IXGBE_VFRDBAH(0), 2, PATTERN_TEST, 0xFFFFFFFF, 0xFFFFFFFF }, 552 { IXGBE_VFRDLEN(0), 2, PATTERN_TEST, 0x000FFF80, 0x000FFFFF }, 553 { IXGBE_VFRXDCTL(0), 2, WRITE_NO_TEST, 0, IXGBE_RXDCTL_ENABLE }, 554 { IXGBE_VFRDT(0), 2, PATTERN_TEST, 0x0000FFFF, 0x0000FFFF }, 555 { IXGBE_VFRXDCTL(0), 2, WRITE_NO_TEST, 0, 0 }, 556 { IXGBE_VFTDBAL(0), 2, PATTERN_TEST, 0xFFFFFF80, 0xFFFFFFFF }, 557 { IXGBE_VFTDBAH(0), 2, PATTERN_TEST, 0xFFFFFFFF, 0xFFFFFFFF }, 558 { IXGBE_VFTDLEN(0), 2, PATTERN_TEST, 0x000FFF80, 0x000FFF80 }, 559 { 0, 0, 0, 0 } 560}; 561 562static const u32 register_test_patterns[] = { 563 0x5A5A5A5A, 0xA5A5A5A5, 0x00000000, 0xFFFFFFFF 564}; 565 566#define REG_PATTERN_TEST(R, M, W) \ 567{ \ 568 u32 pat, val, before; \ 569 for (pat = 0; pat < ARRAY_SIZE(register_test_patterns); pat++) { \ 570 before = readl(adapter->hw.hw_addr + R); \ 571 writel((register_test_patterns[pat] & W), \ 572 (adapter->hw.hw_addr + R)); \ 573 val = readl(adapter->hw.hw_addr + R); \ 574 if (val != (register_test_patterns[pat] & W & M)) { \ 575 hw_dbg(&adapter->hw, \ 576 "pattern test reg %04X failed: got " \ 577 "0x%08X expected 0x%08X\n", \ 578 R, val, (register_test_patterns[pat] & W & M)); \ 579 *data = R; \ 580 writel(before, adapter->hw.hw_addr + R); \ 581 return 1; \ 582 } \ 583 writel(before, adapter->hw.hw_addr + R); \ 584 } \ 585} 586 587#define REG_SET_AND_CHECK(R, M, W) \ 588{ \ 589 u32 val, before; \ 590 before = readl(adapter->hw.hw_addr + R); \ 591 writel((W & M), (adapter->hw.hw_addr + R)); \ 592 val = readl(adapter->hw.hw_addr + R); \ 593 if ((W & M) != (val & M)) { \ 594 printk(KERN_ERR "set/check reg %04X test failed: got 0x%08X " \ 595 "expected 0x%08X\n", R, (val & M), (W & M)); \ 596 *data = R; \ 597 writel(before, (adapter->hw.hw_addr + R)); \ 598 return 1; \ 599 } \ 600 writel(before, (adapter->hw.hw_addr + R)); \ 601} 602 603static int ixgbevf_reg_test(struct ixgbevf_adapter *adapter, u64 *data) 604{ 605 const struct ixgbevf_reg_test *test; 606 u32 i; 607 608 test = reg_test_vf; 609 610 /* 611 * Perform the register test, looping through the test table 612 * until we either fail or reach the null entry. 613 */ 614 while (test->reg) { 615 for (i = 0; i < test->array_len; i++) { 616 switch (test->test_type) { 617 case PATTERN_TEST: 618 REG_PATTERN_TEST(test->reg + (i * 0x40), 619 test->mask, 620 test->write); 621 break; 622 case SET_READ_TEST: 623 REG_SET_AND_CHECK(test->reg + (i * 0x40), 624 test->mask, 625 test->write); 626 break; 627 case WRITE_NO_TEST: 628 writel(test->write, 629 (adapter->hw.hw_addr + test->reg) 630 + (i * 0x40)); 631 break; 632 case TABLE32_TEST: 633 REG_PATTERN_TEST(test->reg + (i * 4), 634 test->mask, 635 test->write); 636 break; 637 case TABLE64_TEST_LO: 638 REG_PATTERN_TEST(test->reg + (i * 8), 639 test->mask, 640 test->write); 641 break; 642 case TABLE64_TEST_HI: 643 REG_PATTERN_TEST((test->reg + 4) + (i * 8), 644 test->mask, 645 test->write); 646 break; 647 } 648 } 649 test++; 650 } 651 652 *data = 0; 653 return *data; 654} 655 656static void ixgbevf_diag_test(struct net_device *netdev, 657 struct ethtool_test *eth_test, u64 *data) 658{ 659 struct ixgbevf_adapter *adapter = netdev_priv(netdev); 660 bool if_running = netif_running(netdev); 661 662 set_bit(__IXGBEVF_TESTING, &adapter->state); 663 if (eth_test->flags == ETH_TEST_FL_OFFLINE) { 664 /* Offline tests */ 665 666 hw_dbg(&adapter->hw, "offline testing starting\n"); 667 668 /* Link test performed before hardware reset so autoneg doesn't 669 * interfere with test result */ 670 if (ixgbevf_link_test(adapter, &data[1])) 671 eth_test->flags |= ETH_TEST_FL_FAILED; 672 673 if (if_running) 674 /* indicate we're in test mode */ 675 dev_close(netdev); 676 else 677 ixgbevf_reset(adapter); 678 679 hw_dbg(&adapter->hw, "register testing starting\n"); 680 if (ixgbevf_reg_test(adapter, &data[0])) 681 eth_test->flags |= ETH_TEST_FL_FAILED; 682 683 ixgbevf_reset(adapter); 684 685 clear_bit(__IXGBEVF_TESTING, &adapter->state); 686 if (if_running) 687 dev_open(netdev); 688 } else { 689 hw_dbg(&adapter->hw, "online testing starting\n"); 690 /* Online tests */ 691 if (ixgbevf_link_test(adapter, &data[1])) 692 eth_test->flags |= ETH_TEST_FL_FAILED; 693 694 /* Online tests aren't run; pass by default */ 695 data[0] = 0; 696 697 clear_bit(__IXGBEVF_TESTING, &adapter->state); 698 } 699 msleep_interruptible(4 * 1000); 700} 701 702static int ixgbevf_nway_reset(struct net_device *netdev) 703{ 704 struct ixgbevf_adapter *adapter = netdev_priv(netdev); 705 706 if (netif_running(netdev)) { 707 if (!adapter->dev_closed) 708 ixgbevf_reinit_locked(adapter); 709 } 710 711 return 0; 712} 713 714static struct ethtool_ops ixgbevf_ethtool_ops = { 715 .get_settings = ixgbevf_get_settings, 716 .get_drvinfo = ixgbevf_get_drvinfo, 717 .get_regs_len = ixgbevf_get_regs_len, 718 .get_regs = ixgbevf_get_regs, 719 .nway_reset = ixgbevf_nway_reset, 720 .get_link = ethtool_op_get_link, 721 .get_ringparam = ixgbevf_get_ringparam, 722 .set_ringparam = ixgbevf_set_ringparam, 723 .get_rx_csum = ixgbevf_get_rx_csum, 724 .set_rx_csum = ixgbevf_set_rx_csum, 725 .get_tx_csum = ethtool_op_get_tx_csum, 726 .set_tx_csum = ethtool_op_set_tx_ipv6_csum, 727 .get_sg = ethtool_op_get_sg, 728 .set_sg = ethtool_op_set_sg, 729 .get_msglevel = ixgbevf_get_msglevel, 730 .set_msglevel = ixgbevf_set_msglevel, 731 .get_tso = ethtool_op_get_tso, 732 .set_tso = ixgbevf_set_tso, 733 .self_test = ixgbevf_diag_test, 734 .get_sset_count = ixgbevf_get_sset_count, 735 .get_strings = ixgbevf_get_strings, 736 .get_ethtool_stats = ixgbevf_get_ethtool_stats, 737}; 738 739void ixgbevf_set_ethtool_ops(struct net_device *netdev) 740{ 741 SET_ETHTOOL_OPS(netdev, &ixgbevf_ethtool_ops); 742}