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 ecmd->speed = (link_speed == IXGBE_LINK_SPEED_10GB_FULL) ? 108 SPEED_10000 : SPEED_1000; 109 ecmd->duplex = DUPLEX_FULL; 110 } else { 111 ecmd->speed = -1; 112 ecmd->duplex = -1; 113 } 114 115 return 0; 116} 117 118static u32 ixgbevf_get_rx_csum(struct net_device *netdev) 119{ 120 struct ixgbevf_adapter *adapter = netdev_priv(netdev); 121 return adapter->flags & IXGBE_FLAG_RX_CSUM_ENABLED; 122} 123 124static int ixgbevf_set_rx_csum(struct net_device *netdev, u32 data) 125{ 126 struct ixgbevf_adapter *adapter = netdev_priv(netdev); 127 if (data) 128 adapter->flags |= IXGBE_FLAG_RX_CSUM_ENABLED; 129 else 130 adapter->flags &= ~IXGBE_FLAG_RX_CSUM_ENABLED; 131 132 if (netif_running(netdev)) { 133 if (!adapter->dev_closed) 134 ixgbevf_reinit_locked(adapter); 135 } else { 136 ixgbevf_reset(adapter); 137 } 138 139 return 0; 140} 141 142static int ixgbevf_set_tso(struct net_device *netdev, u32 data) 143{ 144 if (data) { 145 netdev->features |= NETIF_F_TSO; 146 netdev->features |= NETIF_F_TSO6; 147 } else { 148 netif_tx_stop_all_queues(netdev); 149 netdev->features &= ~NETIF_F_TSO; 150 netdev->features &= ~NETIF_F_TSO6; 151 netif_tx_start_all_queues(netdev); 152 } 153 return 0; 154} 155 156static u32 ixgbevf_get_msglevel(struct net_device *netdev) 157{ 158 struct ixgbevf_adapter *adapter = netdev_priv(netdev); 159 return adapter->msg_enable; 160} 161 162static void ixgbevf_set_msglevel(struct net_device *netdev, u32 data) 163{ 164 struct ixgbevf_adapter *adapter = netdev_priv(netdev); 165 adapter->msg_enable = data; 166} 167 168#define IXGBE_GET_STAT(_A_, _R_) (_A_->stats._R_) 169 170static char *ixgbevf_reg_names[] = { 171 "IXGBE_VFCTRL", 172 "IXGBE_VFSTATUS", 173 "IXGBE_VFLINKS", 174 "IXGBE_VFRXMEMWRAP", 175 "IXGBE_VFRTIMER", 176 "IXGBE_VTEICR", 177 "IXGBE_VTEICS", 178 "IXGBE_VTEIMS", 179 "IXGBE_VTEIMC", 180 "IXGBE_VTEIAC", 181 "IXGBE_VTEIAM", 182 "IXGBE_VTEITR", 183 "IXGBE_VTIVAR", 184 "IXGBE_VTIVAR_MISC", 185 "IXGBE_VFRDBAL0", 186 "IXGBE_VFRDBAL1", 187 "IXGBE_VFRDBAH0", 188 "IXGBE_VFRDBAH1", 189 "IXGBE_VFRDLEN0", 190 "IXGBE_VFRDLEN1", 191 "IXGBE_VFRDH0", 192 "IXGBE_VFRDH1", 193 "IXGBE_VFRDT0", 194 "IXGBE_VFRDT1", 195 "IXGBE_VFRXDCTL0", 196 "IXGBE_VFRXDCTL1", 197 "IXGBE_VFSRRCTL0", 198 "IXGBE_VFSRRCTL1", 199 "IXGBE_VFPSRTYPE", 200 "IXGBE_VFTDBAL0", 201 "IXGBE_VFTDBAL1", 202 "IXGBE_VFTDBAH0", 203 "IXGBE_VFTDBAH1", 204 "IXGBE_VFTDLEN0", 205 "IXGBE_VFTDLEN1", 206 "IXGBE_VFTDH0", 207 "IXGBE_VFTDH1", 208 "IXGBE_VFTDT0", 209 "IXGBE_VFTDT1", 210 "IXGBE_VFTXDCTL0", 211 "IXGBE_VFTXDCTL1", 212 "IXGBE_VFTDWBAL0", 213 "IXGBE_VFTDWBAL1", 214 "IXGBE_VFTDWBAH0", 215 "IXGBE_VFTDWBAH1" 216}; 217 218 219static int ixgbevf_get_regs_len(struct net_device *netdev) 220{ 221 return (ARRAY_SIZE(ixgbevf_reg_names)) * sizeof(u32); 222} 223 224static void ixgbevf_get_regs(struct net_device *netdev, 225 struct ethtool_regs *regs, 226 void *p) 227{ 228 struct ixgbevf_adapter *adapter = netdev_priv(netdev); 229 struct ixgbe_hw *hw = &adapter->hw; 230 u32 *regs_buff = p; 231 u32 regs_len = ixgbevf_get_regs_len(netdev); 232 u8 i; 233 234 memset(p, 0, regs_len); 235 236 regs->version = (1 << 24) | hw->revision_id << 16 | hw->device_id; 237 238 /* General Registers */ 239 regs_buff[0] = IXGBE_READ_REG(hw, IXGBE_VFCTRL); 240 regs_buff[1] = IXGBE_READ_REG(hw, IXGBE_VFSTATUS); 241 regs_buff[2] = IXGBE_READ_REG(hw, IXGBE_VFLINKS); 242 regs_buff[3] = IXGBE_READ_REG(hw, IXGBE_VFRXMEMWRAP); 243 regs_buff[4] = IXGBE_READ_REG(hw, IXGBE_VFRTIMER); 244 245 /* Interrupt */ 246 /* don't read EICR because it can clear interrupt causes, instead 247 * read EICS which is a shadow but doesn't clear EICR */ 248 regs_buff[5] = IXGBE_READ_REG(hw, IXGBE_VTEICS); 249 regs_buff[6] = IXGBE_READ_REG(hw, IXGBE_VTEICS); 250 regs_buff[7] = IXGBE_READ_REG(hw, IXGBE_VTEIMS); 251 regs_buff[8] = IXGBE_READ_REG(hw, IXGBE_VTEIMC); 252 regs_buff[9] = IXGBE_READ_REG(hw, IXGBE_VTEIAC); 253 regs_buff[10] = IXGBE_READ_REG(hw, IXGBE_VTEIAM); 254 regs_buff[11] = IXGBE_READ_REG(hw, IXGBE_VTEITR(0)); 255 regs_buff[12] = IXGBE_READ_REG(hw, IXGBE_VTIVAR(0)); 256 regs_buff[13] = IXGBE_READ_REG(hw, IXGBE_VTIVAR_MISC); 257 258 /* Receive DMA */ 259 for (i = 0; i < 2; i++) 260 regs_buff[14 + i] = IXGBE_READ_REG(hw, IXGBE_VFRDBAL(i)); 261 for (i = 0; i < 2; i++) 262 regs_buff[16 + i] = IXGBE_READ_REG(hw, IXGBE_VFRDBAH(i)); 263 for (i = 0; i < 2; i++) 264 regs_buff[18 + i] = IXGBE_READ_REG(hw, IXGBE_VFRDLEN(i)); 265 for (i = 0; i < 2; i++) 266 regs_buff[20 + i] = IXGBE_READ_REG(hw, IXGBE_VFRDH(i)); 267 for (i = 0; i < 2; i++) 268 regs_buff[22 + i] = IXGBE_READ_REG(hw, IXGBE_VFRDT(i)); 269 for (i = 0; i < 2; i++) 270 regs_buff[24 + i] = IXGBE_READ_REG(hw, IXGBE_VFRXDCTL(i)); 271 for (i = 0; i < 2; i++) 272 regs_buff[26 + i] = IXGBE_READ_REG(hw, IXGBE_VFSRRCTL(i)); 273 274 /* Receive */ 275 regs_buff[28] = IXGBE_READ_REG(hw, IXGBE_VFPSRTYPE); 276 277 /* Transmit */ 278 for (i = 0; i < 2; i++) 279 regs_buff[29 + i] = IXGBE_READ_REG(hw, IXGBE_VFTDBAL(i)); 280 for (i = 0; i < 2; i++) 281 regs_buff[31 + i] = IXGBE_READ_REG(hw, IXGBE_VFTDBAH(i)); 282 for (i = 0; i < 2; i++) 283 regs_buff[33 + i] = IXGBE_READ_REG(hw, IXGBE_VFTDLEN(i)); 284 for (i = 0; i < 2; i++) 285 regs_buff[35 + i] = IXGBE_READ_REG(hw, IXGBE_VFTDH(i)); 286 for (i = 0; i < 2; i++) 287 regs_buff[37 + i] = IXGBE_READ_REG(hw, IXGBE_VFTDT(i)); 288 for (i = 0; i < 2; i++) 289 regs_buff[39 + i] = IXGBE_READ_REG(hw, IXGBE_VFTXDCTL(i)); 290 for (i = 0; i < 2; i++) 291 regs_buff[41 + i] = IXGBE_READ_REG(hw, IXGBE_VFTDWBAL(i)); 292 for (i = 0; i < 2; i++) 293 regs_buff[43 + i] = IXGBE_READ_REG(hw, IXGBE_VFTDWBAH(i)); 294 295 for (i = 0; i < ARRAY_SIZE(ixgbevf_reg_names); i++) 296 hw_dbg(hw, "%s\t%8.8x\n", ixgbevf_reg_names[i], regs_buff[i]); 297} 298 299static void ixgbevf_get_drvinfo(struct net_device *netdev, 300 struct ethtool_drvinfo *drvinfo) 301{ 302 struct ixgbevf_adapter *adapter = netdev_priv(netdev); 303 304 strlcpy(drvinfo->driver, ixgbevf_driver_name, 32); 305 strlcpy(drvinfo->version, ixgbevf_driver_version, 32); 306 307 strlcpy(drvinfo->fw_version, "N/A", 4); 308 strlcpy(drvinfo->bus_info, pci_name(adapter->pdev), 32); 309} 310 311static void ixgbevf_get_ringparam(struct net_device *netdev, 312 struct ethtool_ringparam *ring) 313{ 314 struct ixgbevf_adapter *adapter = netdev_priv(netdev); 315 struct ixgbevf_ring *tx_ring = adapter->tx_ring; 316 struct ixgbevf_ring *rx_ring = adapter->rx_ring; 317 318 ring->rx_max_pending = IXGBEVF_MAX_RXD; 319 ring->tx_max_pending = IXGBEVF_MAX_TXD; 320 ring->rx_mini_max_pending = 0; 321 ring->rx_jumbo_max_pending = 0; 322 ring->rx_pending = rx_ring->count; 323 ring->tx_pending = tx_ring->count; 324 ring->rx_mini_pending = 0; 325 ring->rx_jumbo_pending = 0; 326} 327 328static int ixgbevf_set_ringparam(struct net_device *netdev, 329 struct ethtool_ringparam *ring) 330{ 331 struct ixgbevf_adapter *adapter = netdev_priv(netdev); 332 struct ixgbevf_ring *tx_ring = NULL, *rx_ring = NULL; 333 int i, err; 334 u32 new_rx_count, new_tx_count; 335 bool need_tx_update = false; 336 bool need_rx_update = false; 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 if (new_tx_count != adapter->tx_ring_count) { 359 tx_ring = kcalloc(adapter->num_tx_queues, 360 sizeof(struct ixgbevf_ring), GFP_KERNEL); 361 if (!tx_ring) { 362 err = -ENOMEM; 363 goto err_setup; 364 } 365 memcpy(tx_ring, adapter->tx_ring, 366 adapter->num_tx_queues * sizeof(struct ixgbevf_ring)); 367 for (i = 0; i < adapter->num_tx_queues; i++) { 368 tx_ring[i].count = new_tx_count; 369 err = ixgbevf_setup_tx_resources(adapter, 370 &tx_ring[i]); 371 if (err) { 372 while (i) { 373 i--; 374 ixgbevf_free_tx_resources(adapter, 375 &tx_ring[i]); 376 } 377 kfree(tx_ring); 378 goto err_setup; 379 } 380 tx_ring[i].v_idx = adapter->tx_ring[i].v_idx; 381 } 382 need_tx_update = true; 383 } 384 385 if (new_rx_count != adapter->rx_ring_count) { 386 rx_ring = kcalloc(adapter->num_rx_queues, 387 sizeof(struct ixgbevf_ring), GFP_KERNEL); 388 if ((!rx_ring) && (need_tx_update)) { 389 err = -ENOMEM; 390 goto err_rx_setup; 391 } 392 memcpy(rx_ring, adapter->rx_ring, 393 adapter->num_rx_queues * sizeof(struct ixgbevf_ring)); 394 for (i = 0; i < adapter->num_rx_queues; i++) { 395 rx_ring[i].count = new_rx_count; 396 err = ixgbevf_setup_rx_resources(adapter, 397 &rx_ring[i]); 398 if (err) { 399 while (i) { 400 i--; 401 ixgbevf_free_rx_resources(adapter, 402 &rx_ring[i]); 403 } 404 kfree(rx_ring); 405 goto err_rx_setup; 406 } 407 rx_ring[i].v_idx = adapter->rx_ring[i].v_idx; 408 } 409 need_rx_update = true; 410 } 411 412err_rx_setup: 413 /* if rings need to be updated, here's the place to do it in one shot */ 414 if (need_tx_update || need_rx_update) { 415 if (netif_running(netdev)) 416 ixgbevf_down(adapter); 417 } 418 419 /* tx */ 420 if (need_tx_update) { 421 kfree(adapter->tx_ring); 422 adapter->tx_ring = tx_ring; 423 tx_ring = NULL; 424 adapter->tx_ring_count = new_tx_count; 425 } 426 427 /* rx */ 428 if (need_rx_update) { 429 kfree(adapter->rx_ring); 430 adapter->rx_ring = rx_ring; 431 rx_ring = NULL; 432 adapter->rx_ring_count = new_rx_count; 433 } 434 435 /* success! */ 436 err = 0; 437 if (netif_running(netdev)) 438 ixgbevf_up(adapter); 439 440err_setup: 441 clear_bit(__IXGBEVF_RESETTING, &adapter->state); 442 return err; 443} 444 445static int ixgbevf_get_sset_count(struct net_device *dev, int stringset) 446{ 447 switch (stringset) { 448 case ETH_SS_TEST: 449 return IXGBE_TEST_LEN; 450 case ETH_SS_STATS: 451 return IXGBE_GLOBAL_STATS_LEN; 452 default: 453 return -EINVAL; 454 } 455} 456 457static void ixgbevf_get_ethtool_stats(struct net_device *netdev, 458 struct ethtool_stats *stats, u64 *data) 459{ 460 struct ixgbevf_adapter *adapter = netdev_priv(netdev); 461 int i; 462 463 ixgbevf_update_stats(adapter); 464 for (i = 0; i < IXGBE_GLOBAL_STATS_LEN; i++) { 465 char *p = (char *)adapter + 466 ixgbe_gstrings_stats[i].stat_offset; 467 char *b = (char *)adapter + 468 ixgbe_gstrings_stats[i].base_stat_offset; 469 char *r = (char *)adapter + 470 ixgbe_gstrings_stats[i].saved_reset_offset; 471 data[i] = ((ixgbe_gstrings_stats[i].sizeof_stat == 472 sizeof(u64)) ? *(u64 *)p : *(u32 *)p) - 473 ((ixgbe_gstrings_stats[i].sizeof_stat == 474 sizeof(u64)) ? *(u64 *)b : *(u32 *)b) + 475 ((ixgbe_gstrings_stats[i].sizeof_stat == 476 sizeof(u64)) ? *(u64 *)r : *(u32 *)r); 477 } 478} 479 480static void ixgbevf_get_strings(struct net_device *netdev, u32 stringset, 481 u8 *data) 482{ 483 char *p = (char *)data; 484 int i; 485 486 switch (stringset) { 487 case ETH_SS_TEST: 488 memcpy(data, *ixgbe_gstrings_test, 489 IXGBE_TEST_LEN * ETH_GSTRING_LEN); 490 break; 491 case ETH_SS_STATS: 492 for (i = 0; i < IXGBE_GLOBAL_STATS_LEN; i++) { 493 memcpy(p, ixgbe_gstrings_stats[i].stat_string, 494 ETH_GSTRING_LEN); 495 p += ETH_GSTRING_LEN; 496 } 497 break; 498 } 499} 500 501static int ixgbevf_link_test(struct ixgbevf_adapter *adapter, u64 *data) 502{ 503 struct ixgbe_hw *hw = &adapter->hw; 504 bool link_up; 505 u32 link_speed = 0; 506 *data = 0; 507 508 hw->mac.ops.check_link(hw, &link_speed, &link_up, true); 509 if (!link_up) 510 *data = 1; 511 512 return *data; 513} 514 515/* ethtool register test data */ 516struct ixgbevf_reg_test { 517 u16 reg; 518 u8 array_len; 519 u8 test_type; 520 u32 mask; 521 u32 write; 522}; 523 524/* In the hardware, registers are laid out either singly, in arrays 525 * spaced 0x40 bytes apart, or in contiguous tables. We assume 526 * most tests take place on arrays or single registers (handled 527 * as a single-element array) and special-case the tables. 528 * Table tests are always pattern tests. 529 * 530 * We also make provision for some required setup steps by specifying 531 * registers to be written without any read-back testing. 532 */ 533 534#define PATTERN_TEST 1 535#define SET_READ_TEST 2 536#define WRITE_NO_TEST 3 537#define TABLE32_TEST 4 538#define TABLE64_TEST_LO 5 539#define TABLE64_TEST_HI 6 540 541/* default VF register test */ 542static struct ixgbevf_reg_test reg_test_vf[] = { 543 { IXGBE_VFRDBAL(0), 2, PATTERN_TEST, 0xFFFFFF80, 0xFFFFFF80 }, 544 { IXGBE_VFRDBAH(0), 2, PATTERN_TEST, 0xFFFFFFFF, 0xFFFFFFFF }, 545 { IXGBE_VFRDLEN(0), 2, PATTERN_TEST, 0x000FFF80, 0x000FFFFF }, 546 { IXGBE_VFRXDCTL(0), 2, WRITE_NO_TEST, 0, IXGBE_RXDCTL_ENABLE }, 547 { IXGBE_VFRDT(0), 2, PATTERN_TEST, 0x0000FFFF, 0x0000FFFF }, 548 { IXGBE_VFRXDCTL(0), 2, WRITE_NO_TEST, 0, 0 }, 549 { IXGBE_VFTDBAL(0), 2, PATTERN_TEST, 0xFFFFFF80, 0xFFFFFFFF }, 550 { IXGBE_VFTDBAH(0), 2, PATTERN_TEST, 0xFFFFFFFF, 0xFFFFFFFF }, 551 { IXGBE_VFTDLEN(0), 2, PATTERN_TEST, 0x000FFF80, 0x000FFF80 }, 552 { 0, 0, 0, 0 } 553}; 554 555#define REG_PATTERN_TEST(R, M, W) \ 556{ \ 557 u32 pat, val, before; \ 558 const u32 _test[] = {0x5A5A5A5A, 0xA5A5A5A5, 0x00000000, 0xFFFFFFFF}; \ 559 for (pat = 0; pat < ARRAY_SIZE(_test); pat++) { \ 560 before = readl(adapter->hw.hw_addr + R); \ 561 writel((_test[pat] & W), (adapter->hw.hw_addr + R)); \ 562 val = readl(adapter->hw.hw_addr + R); \ 563 if (val != (_test[pat] & W & M)) { \ 564 hw_dbg(&adapter->hw, \ 565 "pattern test reg %04X failed: got " \ 566 "0x%08X expected 0x%08X\n", \ 567 R, val, (_test[pat] & W & M)); \ 568 *data = R; \ 569 writel(before, adapter->hw.hw_addr + R); \ 570 return 1; \ 571 } \ 572 writel(before, adapter->hw.hw_addr + R); \ 573 } \ 574} 575 576#define REG_SET_AND_CHECK(R, M, W) \ 577{ \ 578 u32 val, before; \ 579 before = readl(adapter->hw.hw_addr + R); \ 580 writel((W & M), (adapter->hw.hw_addr + R)); \ 581 val = readl(adapter->hw.hw_addr + R); \ 582 if ((W & M) != (val & M)) { \ 583 printk(KERN_ERR "set/check reg %04X test failed: got 0x%08X " \ 584 "expected 0x%08X\n", R, (val & M), (W & M)); \ 585 *data = R; \ 586 writel(before, (adapter->hw.hw_addr + R)); \ 587 return 1; \ 588 } \ 589 writel(before, (adapter->hw.hw_addr + R)); \ 590} 591 592static int ixgbevf_reg_test(struct ixgbevf_adapter *adapter, u64 *data) 593{ 594 struct ixgbevf_reg_test *test; 595 u32 i; 596 597 test = reg_test_vf; 598 599 /* 600 * Perform the register test, looping through the test table 601 * until we either fail or reach the null entry. 602 */ 603 while (test->reg) { 604 for (i = 0; i < test->array_len; i++) { 605 switch (test->test_type) { 606 case PATTERN_TEST: 607 REG_PATTERN_TEST(test->reg + (i * 0x40), 608 test->mask, 609 test->write); 610 break; 611 case SET_READ_TEST: 612 REG_SET_AND_CHECK(test->reg + (i * 0x40), 613 test->mask, 614 test->write); 615 break; 616 case WRITE_NO_TEST: 617 writel(test->write, 618 (adapter->hw.hw_addr + test->reg) 619 + (i * 0x40)); 620 break; 621 case TABLE32_TEST: 622 REG_PATTERN_TEST(test->reg + (i * 4), 623 test->mask, 624 test->write); 625 break; 626 case TABLE64_TEST_LO: 627 REG_PATTERN_TEST(test->reg + (i * 8), 628 test->mask, 629 test->write); 630 break; 631 case TABLE64_TEST_HI: 632 REG_PATTERN_TEST((test->reg + 4) + (i * 8), 633 test->mask, 634 test->write); 635 break; 636 } 637 } 638 test++; 639 } 640 641 *data = 0; 642 return *data; 643} 644 645static void ixgbevf_diag_test(struct net_device *netdev, 646 struct ethtool_test *eth_test, u64 *data) 647{ 648 struct ixgbevf_adapter *adapter = netdev_priv(netdev); 649 bool if_running = netif_running(netdev); 650 651 set_bit(__IXGBEVF_TESTING, &adapter->state); 652 if (eth_test->flags == ETH_TEST_FL_OFFLINE) { 653 /* Offline tests */ 654 655 hw_dbg(&adapter->hw, "offline testing starting\n"); 656 657 /* Link test performed before hardware reset so autoneg doesn't 658 * interfere with test result */ 659 if (ixgbevf_link_test(adapter, &data[1])) 660 eth_test->flags |= ETH_TEST_FL_FAILED; 661 662 if (if_running) 663 /* indicate we're in test mode */ 664 dev_close(netdev); 665 else 666 ixgbevf_reset(adapter); 667 668 hw_dbg(&adapter->hw, "register testing starting\n"); 669 if (ixgbevf_reg_test(adapter, &data[0])) 670 eth_test->flags |= ETH_TEST_FL_FAILED; 671 672 ixgbevf_reset(adapter); 673 674 clear_bit(__IXGBEVF_TESTING, &adapter->state); 675 if (if_running) 676 dev_open(netdev); 677 } else { 678 hw_dbg(&adapter->hw, "online testing starting\n"); 679 /* Online tests */ 680 if (ixgbevf_link_test(adapter, &data[1])) 681 eth_test->flags |= ETH_TEST_FL_FAILED; 682 683 /* Online tests aren't run; pass by default */ 684 data[0] = 0; 685 686 clear_bit(__IXGBEVF_TESTING, &adapter->state); 687 } 688 msleep_interruptible(4 * 1000); 689} 690 691static int ixgbevf_nway_reset(struct net_device *netdev) 692{ 693 struct ixgbevf_adapter *adapter = netdev_priv(netdev); 694 695 if (netif_running(netdev)) { 696 if (!adapter->dev_closed) 697 ixgbevf_reinit_locked(adapter); 698 } 699 700 return 0; 701} 702 703static struct ethtool_ops ixgbevf_ethtool_ops = { 704 .get_settings = ixgbevf_get_settings, 705 .get_drvinfo = ixgbevf_get_drvinfo, 706 .get_regs_len = ixgbevf_get_regs_len, 707 .get_regs = ixgbevf_get_regs, 708 .nway_reset = ixgbevf_nway_reset, 709 .get_link = ethtool_op_get_link, 710 .get_ringparam = ixgbevf_get_ringparam, 711 .set_ringparam = ixgbevf_set_ringparam, 712 .get_rx_csum = ixgbevf_get_rx_csum, 713 .set_rx_csum = ixgbevf_set_rx_csum, 714 .get_tx_csum = ethtool_op_get_tx_csum, 715 .set_tx_csum = ethtool_op_set_tx_ipv6_csum, 716 .get_sg = ethtool_op_get_sg, 717 .set_sg = ethtool_op_set_sg, 718 .get_msglevel = ixgbevf_get_msglevel, 719 .set_msglevel = ixgbevf_set_msglevel, 720 .get_tso = ethtool_op_get_tso, 721 .set_tso = ixgbevf_set_tso, 722 .self_test = ixgbevf_diag_test, 723 .get_sset_count = ixgbevf_get_sset_count, 724 .get_strings = ixgbevf_get_strings, 725 .get_ethtool_stats = ixgbevf_get_ethtool_stats, 726}; 727 728void ixgbevf_set_ethtool_ops(struct net_device *netdev) 729{ 730 SET_ETHTOOL_OPS(netdev, &ixgbevf_ethtool_ops); 731} 732