1 /******************************************************************************* 2 3 Intel PRO/1000 Linux driver 4 Copyright(c) 1999 - 2012 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 Linux NICS <linux.nics@intel.com> 24 e1000-devel Mailing List <e1000-devel@lists.sourceforge.net> 25 Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497 26 27 *******************************************************************************/ 28 29 /* ethtool support for e1000 */ 30 31 #include <linux/netdevice.h> 32 #include <linux/interrupt.h> 33 #include <linux/ethtool.h> 34 #include <linux/pci.h> 35 #include <linux/slab.h> 36 #include <linux/delay.h> 37 #include <linux/vmalloc.h> 38 39 #include "e1000.h" 40 41 enum {NETDEV_STATS, E1000_STATS}; 42 43 struct e1000_stats { 44 char stat_string[ETH_GSTRING_LEN]; 45 int type; 46 int sizeof_stat; 47 int stat_offset; 48 }; 49 50 #define E1000_STAT(str, m) { \ 51 .stat_string = str, \ 52 .type = E1000_STATS, \ 53 .sizeof_stat = sizeof(((struct e1000_adapter *)0)->m), \ 54 .stat_offset = offsetof(struct e1000_adapter, m) } 55 #define E1000_NETDEV_STAT(str, m) { \ 56 .stat_string = str, \ 57 .type = NETDEV_STATS, \ 58 .sizeof_stat = sizeof(((struct rtnl_link_stats64 *)0)->m), \ 59 .stat_offset = offsetof(struct rtnl_link_stats64, m) } 60 61 static const struct e1000_stats e1000_gstrings_stats[] = { 62 E1000_STAT("rx_packets", stats.gprc), 63 E1000_STAT("tx_packets", stats.gptc), 64 E1000_STAT("rx_bytes", stats.gorc), 65 E1000_STAT("tx_bytes", stats.gotc), 66 E1000_STAT("rx_broadcast", stats.bprc), 67 E1000_STAT("tx_broadcast", stats.bptc), 68 E1000_STAT("rx_multicast", stats.mprc), 69 E1000_STAT("tx_multicast", stats.mptc), 70 E1000_NETDEV_STAT("rx_errors", rx_errors), 71 E1000_NETDEV_STAT("tx_errors", tx_errors), 72 E1000_NETDEV_STAT("tx_dropped", tx_dropped), 73 E1000_STAT("multicast", stats.mprc), 74 E1000_STAT("collisions", stats.colc), 75 E1000_NETDEV_STAT("rx_length_errors", rx_length_errors), 76 E1000_NETDEV_STAT("rx_over_errors", rx_over_errors), 77 E1000_STAT("rx_crc_errors", stats.crcerrs), 78 E1000_NETDEV_STAT("rx_frame_errors", rx_frame_errors), 79 E1000_STAT("rx_no_buffer_count", stats.rnbc), 80 E1000_STAT("rx_missed_errors", stats.mpc), 81 E1000_STAT("tx_aborted_errors", stats.ecol), 82 E1000_STAT("tx_carrier_errors", stats.tncrs), 83 E1000_NETDEV_STAT("tx_fifo_errors", tx_fifo_errors), 84 E1000_NETDEV_STAT("tx_heartbeat_errors", tx_heartbeat_errors), 85 E1000_STAT("tx_window_errors", stats.latecol), 86 E1000_STAT("tx_abort_late_coll", stats.latecol), 87 E1000_STAT("tx_deferred_ok", stats.dc), 88 E1000_STAT("tx_single_coll_ok", stats.scc), 89 E1000_STAT("tx_multi_coll_ok", stats.mcc), 90 E1000_STAT("tx_timeout_count", tx_timeout_count), 91 E1000_STAT("tx_restart_queue", restart_queue), 92 E1000_STAT("rx_long_length_errors", stats.roc), 93 E1000_STAT("rx_short_length_errors", stats.ruc), 94 E1000_STAT("rx_align_errors", stats.algnerrc), 95 E1000_STAT("tx_tcp_seg_good", stats.tsctc), 96 E1000_STAT("tx_tcp_seg_failed", stats.tsctfc), 97 E1000_STAT("rx_flow_control_xon", stats.xonrxc), 98 E1000_STAT("rx_flow_control_xoff", stats.xoffrxc), 99 E1000_STAT("tx_flow_control_xon", stats.xontxc), 100 E1000_STAT("tx_flow_control_xoff", stats.xofftxc), 101 E1000_STAT("rx_long_byte_count", stats.gorc), 102 E1000_STAT("rx_csum_offload_good", hw_csum_good), 103 E1000_STAT("rx_csum_offload_errors", hw_csum_err), 104 E1000_STAT("rx_header_split", rx_hdr_split), 105 E1000_STAT("alloc_rx_buff_failed", alloc_rx_buff_failed), 106 E1000_STAT("tx_smbus", stats.mgptc), 107 E1000_STAT("rx_smbus", stats.mgprc), 108 E1000_STAT("dropped_smbus", stats.mgpdc), 109 E1000_STAT("rx_dma_failed", rx_dma_failed), 110 E1000_STAT("tx_dma_failed", tx_dma_failed), 111 }; 112 113 #define E1000_GLOBAL_STATS_LEN ARRAY_SIZE(e1000_gstrings_stats) 114 #define E1000_STATS_LEN (E1000_GLOBAL_STATS_LEN) 115 static const char e1000_gstrings_test[][ETH_GSTRING_LEN] = { 116 "Register test (offline)", "Eeprom test (offline)", 117 "Interrupt test (offline)", "Loopback test (offline)", 118 "Link test (on/offline)" 119 }; 120 #define E1000_TEST_LEN ARRAY_SIZE(e1000_gstrings_test) 121 122 static int e1000_get_settings(struct net_device *netdev, 123 struct ethtool_cmd *ecmd) 124 { 125 struct e1000_adapter *adapter = netdev_priv(netdev); 126 struct e1000_hw *hw = &adapter->hw; 127 u32 speed; 128 129 if (hw->phy.media_type == e1000_media_type_copper) { 130 131 ecmd->supported = (SUPPORTED_10baseT_Half | 132 SUPPORTED_10baseT_Full | 133 SUPPORTED_100baseT_Half | 134 SUPPORTED_100baseT_Full | 135 SUPPORTED_1000baseT_Full | 136 SUPPORTED_Autoneg | 137 SUPPORTED_TP); 138 if (hw->phy.type == e1000_phy_ife) 139 ecmd->supported &= ~SUPPORTED_1000baseT_Full; 140 ecmd->advertising = ADVERTISED_TP; 141 142 if (hw->mac.autoneg == 1) { 143 ecmd->advertising |= ADVERTISED_Autoneg; 144 /* the e1000 autoneg seems to match ethtool nicely */ 145 ecmd->advertising |= hw->phy.autoneg_advertised; 146 } 147 148 ecmd->port = PORT_TP; 149 ecmd->phy_address = hw->phy.addr; 150 ecmd->transceiver = XCVR_INTERNAL; 151 152 } else { 153 ecmd->supported = (SUPPORTED_1000baseT_Full | 154 SUPPORTED_FIBRE | 155 SUPPORTED_Autoneg); 156 157 ecmd->advertising = (ADVERTISED_1000baseT_Full | 158 ADVERTISED_FIBRE | 159 ADVERTISED_Autoneg); 160 161 ecmd->port = PORT_FIBRE; 162 ecmd->transceiver = XCVR_EXTERNAL; 163 } 164 165 speed = -1; 166 ecmd->duplex = -1; 167 168 if (netif_running(netdev)) { 169 if (netif_carrier_ok(netdev)) { 170 speed = adapter->link_speed; 171 ecmd->duplex = adapter->link_duplex - 1; 172 } 173 } else { 174 u32 status = er32(STATUS); 175 if (status & E1000_STATUS_LU) { 176 if (status & E1000_STATUS_SPEED_1000) 177 speed = SPEED_1000; 178 else if (status & E1000_STATUS_SPEED_100) 179 speed = SPEED_100; 180 else 181 speed = SPEED_10; 182 183 if (status & E1000_STATUS_FD) 184 ecmd->duplex = DUPLEX_FULL; 185 else 186 ecmd->duplex = DUPLEX_HALF; 187 } 188 } 189 190 ethtool_cmd_speed_set(ecmd, speed); 191 ecmd->autoneg = ((hw->phy.media_type == e1000_media_type_fiber) || 192 hw->mac.autoneg) ? AUTONEG_ENABLE : AUTONEG_DISABLE; 193 194 /* MDI-X => 2; MDI =>1; Invalid =>0 */ 195 if ((hw->phy.media_type == e1000_media_type_copper) && 196 netif_carrier_ok(netdev)) 197 ecmd->eth_tp_mdix = hw->phy.is_mdix ? ETH_TP_MDI_X : 198 ETH_TP_MDI; 199 else 200 ecmd->eth_tp_mdix = ETH_TP_MDI_INVALID; 201 202 return 0; 203 } 204 205 static int e1000_set_spd_dplx(struct e1000_adapter *adapter, u32 spd, u8 dplx) 206 { 207 struct e1000_mac_info *mac = &adapter->hw.mac; 208 209 mac->autoneg = 0; 210 211 /* Make sure dplx is at most 1 bit and lsb of speed is not set 212 * for the switch() below to work */ 213 if ((spd & 1) || (dplx & ~1)) 214 goto err_inval; 215 216 /* Fiber NICs only allow 1000 gbps Full duplex */ 217 if ((adapter->hw.phy.media_type == e1000_media_type_fiber) && 218 spd != SPEED_1000 && 219 dplx != DUPLEX_FULL) { 220 goto err_inval; 221 } 222 223 switch (spd + dplx) { 224 case SPEED_10 + DUPLEX_HALF: 225 mac->forced_speed_duplex = ADVERTISE_10_HALF; 226 break; 227 case SPEED_10 + DUPLEX_FULL: 228 mac->forced_speed_duplex = ADVERTISE_10_FULL; 229 break; 230 case SPEED_100 + DUPLEX_HALF: 231 mac->forced_speed_duplex = ADVERTISE_100_HALF; 232 break; 233 case SPEED_100 + DUPLEX_FULL: 234 mac->forced_speed_duplex = ADVERTISE_100_FULL; 235 break; 236 case SPEED_1000 + DUPLEX_FULL: 237 mac->autoneg = 1; 238 adapter->hw.phy.autoneg_advertised = ADVERTISE_1000_FULL; 239 break; 240 case SPEED_1000 + DUPLEX_HALF: /* not supported */ 241 default: 242 goto err_inval; 243 } 244 return 0; 245 246 err_inval: 247 e_err("Unsupported Speed/Duplex configuration\n"); 248 return -EINVAL; 249 } 250 251 static int e1000_set_settings(struct net_device *netdev, 252 struct ethtool_cmd *ecmd) 253 { 254 struct e1000_adapter *adapter = netdev_priv(netdev); 255 struct e1000_hw *hw = &adapter->hw; 256 257 /* 258 * When SoL/IDER sessions are active, autoneg/speed/duplex 259 * cannot be changed 260 */ 261 if (hw->phy.ops.check_reset_block && 262 hw->phy.ops.check_reset_block(hw)) { 263 e_err("Cannot change link characteristics when SoL/IDER is active.\n"); 264 return -EINVAL; 265 } 266 267 while (test_and_set_bit(__E1000_RESETTING, &adapter->state)) 268 usleep_range(1000, 2000); 269 270 if (ecmd->autoneg == AUTONEG_ENABLE) { 271 hw->mac.autoneg = 1; 272 if (hw->phy.media_type == e1000_media_type_fiber) 273 hw->phy.autoneg_advertised = ADVERTISED_1000baseT_Full | 274 ADVERTISED_FIBRE | 275 ADVERTISED_Autoneg; 276 else 277 hw->phy.autoneg_advertised = ecmd->advertising | 278 ADVERTISED_TP | 279 ADVERTISED_Autoneg; 280 ecmd->advertising = hw->phy.autoneg_advertised; 281 if (adapter->fc_autoneg) 282 hw->fc.requested_mode = e1000_fc_default; 283 } else { 284 u32 speed = ethtool_cmd_speed(ecmd); 285 if (e1000_set_spd_dplx(adapter, speed, ecmd->duplex)) { 286 clear_bit(__E1000_RESETTING, &adapter->state); 287 return -EINVAL; 288 } 289 } 290 291 /* reset the link */ 292 293 if (netif_running(adapter->netdev)) { 294 e1000e_down(adapter); 295 e1000e_up(adapter); 296 } else { 297 e1000e_reset(adapter); 298 } 299 300 clear_bit(__E1000_RESETTING, &adapter->state); 301 return 0; 302 } 303 304 static void e1000_get_pauseparam(struct net_device *netdev, 305 struct ethtool_pauseparam *pause) 306 { 307 struct e1000_adapter *adapter = netdev_priv(netdev); 308 struct e1000_hw *hw = &adapter->hw; 309 310 pause->autoneg = 311 (adapter->fc_autoneg ? AUTONEG_ENABLE : AUTONEG_DISABLE); 312 313 if (hw->fc.current_mode == e1000_fc_rx_pause) { 314 pause->rx_pause = 1; 315 } else if (hw->fc.current_mode == e1000_fc_tx_pause) { 316 pause->tx_pause = 1; 317 } else if (hw->fc.current_mode == e1000_fc_full) { 318 pause->rx_pause = 1; 319 pause->tx_pause = 1; 320 } 321 } 322 323 static int e1000_set_pauseparam(struct net_device *netdev, 324 struct ethtool_pauseparam *pause) 325 { 326 struct e1000_adapter *adapter = netdev_priv(netdev); 327 struct e1000_hw *hw = &adapter->hw; 328 int retval = 0; 329 330 adapter->fc_autoneg = pause->autoneg; 331 332 while (test_and_set_bit(__E1000_RESETTING, &adapter->state)) 333 usleep_range(1000, 2000); 334 335 if (adapter->fc_autoneg == AUTONEG_ENABLE) { 336 hw->fc.requested_mode = e1000_fc_default; 337 if (netif_running(adapter->netdev)) { 338 e1000e_down(adapter); 339 e1000e_up(adapter); 340 } else { 341 e1000e_reset(adapter); 342 } 343 } else { 344 if (pause->rx_pause && pause->tx_pause) 345 hw->fc.requested_mode = e1000_fc_full; 346 else if (pause->rx_pause && !pause->tx_pause) 347 hw->fc.requested_mode = e1000_fc_rx_pause; 348 else if (!pause->rx_pause && pause->tx_pause) 349 hw->fc.requested_mode = e1000_fc_tx_pause; 350 else if (!pause->rx_pause && !pause->tx_pause) 351 hw->fc.requested_mode = e1000_fc_none; 352 353 hw->fc.current_mode = hw->fc.requested_mode; 354 355 if (hw->phy.media_type == e1000_media_type_fiber) { 356 retval = hw->mac.ops.setup_link(hw); 357 /* implicit goto out */ 358 } else { 359 retval = e1000e_force_mac_fc(hw); 360 if (retval) 361 goto out; 362 e1000e_set_fc_watermarks(hw); 363 } 364 } 365 366 out: 367 clear_bit(__E1000_RESETTING, &adapter->state); 368 return retval; 369 } 370 371 static u32 e1000_get_msglevel(struct net_device *netdev) 372 { 373 struct e1000_adapter *adapter = netdev_priv(netdev); 374 return adapter->msg_enable; 375 } 376 377 static void e1000_set_msglevel(struct net_device *netdev, u32 data) 378 { 379 struct e1000_adapter *adapter = netdev_priv(netdev); 380 adapter->msg_enable = data; 381 } 382 383 static int e1000_get_regs_len(struct net_device *netdev) 384 { 385 #define E1000_REGS_LEN 32 /* overestimate */ 386 return E1000_REGS_LEN * sizeof(u32); 387 } 388 389 static void e1000_get_regs(struct net_device *netdev, 390 struct ethtool_regs *regs, void *p) 391 { 392 struct e1000_adapter *adapter = netdev_priv(netdev); 393 struct e1000_hw *hw = &adapter->hw; 394 u32 *regs_buff = p; 395 u16 phy_data; 396 397 memset(p, 0, E1000_REGS_LEN * sizeof(u32)); 398 399 regs->version = (1 << 24) | (adapter->pdev->revision << 16) | 400 adapter->pdev->device; 401 402 regs_buff[0] = er32(CTRL); 403 regs_buff[1] = er32(STATUS); 404 405 regs_buff[2] = er32(RCTL); 406 regs_buff[3] = er32(RDLEN(0)); 407 regs_buff[4] = er32(RDH(0)); 408 regs_buff[5] = er32(RDT(0)); 409 regs_buff[6] = er32(RDTR); 410 411 regs_buff[7] = er32(TCTL); 412 regs_buff[8] = er32(TDLEN(0)); 413 regs_buff[9] = er32(TDH(0)); 414 regs_buff[10] = er32(TDT(0)); 415 regs_buff[11] = er32(TIDV); 416 417 regs_buff[12] = adapter->hw.phy.type; /* PHY type (IGP=1, M88=0) */ 418 419 /* ethtool doesn't use anything past this point, so all this 420 * code is likely legacy junk for apps that may or may not 421 * exist */ 422 if (hw->phy.type == e1000_phy_m88) { 423 e1e_rphy(hw, M88E1000_PHY_SPEC_STATUS, &phy_data); 424 regs_buff[13] = (u32)phy_data; /* cable length */ 425 regs_buff[14] = 0; /* Dummy (to align w/ IGP phy reg dump) */ 426 regs_buff[15] = 0; /* Dummy (to align w/ IGP phy reg dump) */ 427 regs_buff[16] = 0; /* Dummy (to align w/ IGP phy reg dump) */ 428 e1e_rphy(hw, M88E1000_PHY_SPEC_CTRL, &phy_data); 429 regs_buff[17] = (u32)phy_data; /* extended 10bt distance */ 430 regs_buff[18] = regs_buff[13]; /* cable polarity */ 431 regs_buff[19] = 0; /* Dummy (to align w/ IGP phy reg dump) */ 432 regs_buff[20] = regs_buff[17]; /* polarity correction */ 433 /* phy receive errors */ 434 regs_buff[22] = adapter->phy_stats.receive_errors; 435 regs_buff[23] = regs_buff[13]; /* mdix mode */ 436 } 437 regs_buff[21] = 0; /* was idle_errors */ 438 e1e_rphy(hw, PHY_1000T_STATUS, &phy_data); 439 regs_buff[24] = (u32)phy_data; /* phy local receiver status */ 440 regs_buff[25] = regs_buff[24]; /* phy remote receiver status */ 441 } 442 443 static int e1000_get_eeprom_len(struct net_device *netdev) 444 { 445 struct e1000_adapter *adapter = netdev_priv(netdev); 446 return adapter->hw.nvm.word_size * 2; 447 } 448 449 static int e1000_get_eeprom(struct net_device *netdev, 450 struct ethtool_eeprom *eeprom, u8 *bytes) 451 { 452 struct e1000_adapter *adapter = netdev_priv(netdev); 453 struct e1000_hw *hw = &adapter->hw; 454 u16 *eeprom_buff; 455 int first_word; 456 int last_word; 457 int ret_val = 0; 458 u16 i; 459 460 if (eeprom->len == 0) 461 return -EINVAL; 462 463 eeprom->magic = adapter->pdev->vendor | (adapter->pdev->device << 16); 464 465 first_word = eeprom->offset >> 1; 466 last_word = (eeprom->offset + eeprom->len - 1) >> 1; 467 468 eeprom_buff = kmalloc(sizeof(u16) * 469 (last_word - first_word + 1), GFP_KERNEL); 470 if (!eeprom_buff) 471 return -ENOMEM; 472 473 if (hw->nvm.type == e1000_nvm_eeprom_spi) { 474 ret_val = e1000_read_nvm(hw, first_word, 475 last_word - first_word + 1, 476 eeprom_buff); 477 } else { 478 for (i = 0; i < last_word - first_word + 1; i++) { 479 ret_val = e1000_read_nvm(hw, first_word + i, 1, 480 &eeprom_buff[i]); 481 if (ret_val) 482 break; 483 } 484 } 485 486 if (ret_val) { 487 /* a read error occurred, throw away the result */ 488 memset(eeprom_buff, 0xff, sizeof(u16) * 489 (last_word - first_word + 1)); 490 } else { 491 /* Device's eeprom is always little-endian, word addressable */ 492 for (i = 0; i < last_word - first_word + 1; i++) 493 le16_to_cpus(&eeprom_buff[i]); 494 } 495 496 memcpy(bytes, (u8 *)eeprom_buff + (eeprom->offset & 1), eeprom->len); 497 kfree(eeprom_buff); 498 499 return ret_val; 500 } 501 502 static int e1000_set_eeprom(struct net_device *netdev, 503 struct ethtool_eeprom *eeprom, u8 *bytes) 504 { 505 struct e1000_adapter *adapter = netdev_priv(netdev); 506 struct e1000_hw *hw = &adapter->hw; 507 u16 *eeprom_buff; 508 void *ptr; 509 int max_len; 510 int first_word; 511 int last_word; 512 int ret_val = 0; 513 u16 i; 514 515 if (eeprom->len == 0) 516 return -EOPNOTSUPP; 517 518 if (eeprom->magic != (adapter->pdev->vendor | (adapter->pdev->device << 16))) 519 return -EFAULT; 520 521 if (adapter->flags & FLAG_READ_ONLY_NVM) 522 return -EINVAL; 523 524 max_len = hw->nvm.word_size * 2; 525 526 first_word = eeprom->offset >> 1; 527 last_word = (eeprom->offset + eeprom->len - 1) >> 1; 528 eeprom_buff = kmalloc(max_len, GFP_KERNEL); 529 if (!eeprom_buff) 530 return -ENOMEM; 531 532 ptr = (void *)eeprom_buff; 533 534 if (eeprom->offset & 1) { 535 /* need read/modify/write of first changed EEPROM word */ 536 /* only the second byte of the word is being modified */ 537 ret_val = e1000_read_nvm(hw, first_word, 1, &eeprom_buff[0]); 538 ptr++; 539 } 540 if (((eeprom->offset + eeprom->len) & 1) && (!ret_val)) 541 /* need read/modify/write of last changed EEPROM word */ 542 /* only the first byte of the word is being modified */ 543 ret_val = e1000_read_nvm(hw, last_word, 1, 544 &eeprom_buff[last_word - first_word]); 545 546 if (ret_val) 547 goto out; 548 549 /* Device's eeprom is always little-endian, word addressable */ 550 for (i = 0; i < last_word - first_word + 1; i++) 551 le16_to_cpus(&eeprom_buff[i]); 552 553 memcpy(ptr, bytes, eeprom->len); 554 555 for (i = 0; i < last_word - first_word + 1; i++) 556 cpu_to_le16s(&eeprom_buff[i]); 557 558 ret_val = e1000_write_nvm(hw, first_word, 559 last_word - first_word + 1, eeprom_buff); 560 561 if (ret_val) 562 goto out; 563 564 /* 565 * Update the checksum over the first part of the EEPROM if needed 566 * and flush shadow RAM for applicable controllers 567 */ 568 if ((first_word <= NVM_CHECKSUM_REG) || 569 (hw->mac.type == e1000_82583) || 570 (hw->mac.type == e1000_82574) || 571 (hw->mac.type == e1000_82573)) 572 ret_val = e1000e_update_nvm_checksum(hw); 573 574 out: 575 kfree(eeprom_buff); 576 return ret_val; 577 } 578 579 static void e1000_get_drvinfo(struct net_device *netdev, 580 struct ethtool_drvinfo *drvinfo) 581 { 582 struct e1000_adapter *adapter = netdev_priv(netdev); 583 584 strlcpy(drvinfo->driver, e1000e_driver_name, 585 sizeof(drvinfo->driver)); 586 strlcpy(drvinfo->version, e1000e_driver_version, 587 sizeof(drvinfo->version)); 588 589 /* 590 * EEPROM image version # is reported as firmware version # for 591 * PCI-E controllers 592 */ 593 snprintf(drvinfo->fw_version, sizeof(drvinfo->fw_version), 594 "%d.%d-%d", 595 (adapter->eeprom_vers & 0xF000) >> 12, 596 (adapter->eeprom_vers & 0x0FF0) >> 4, 597 (adapter->eeprom_vers & 0x000F)); 598 599 strlcpy(drvinfo->bus_info, pci_name(adapter->pdev), 600 sizeof(drvinfo->bus_info)); 601 drvinfo->regdump_len = e1000_get_regs_len(netdev); 602 drvinfo->eedump_len = e1000_get_eeprom_len(netdev); 603 } 604 605 static void e1000_get_ringparam(struct net_device *netdev, 606 struct ethtool_ringparam *ring) 607 { 608 struct e1000_adapter *adapter = netdev_priv(netdev); 609 610 ring->rx_max_pending = E1000_MAX_RXD; 611 ring->tx_max_pending = E1000_MAX_TXD; 612 ring->rx_pending = adapter->rx_ring_count; 613 ring->tx_pending = adapter->tx_ring_count; 614 } 615 616 static int e1000_set_ringparam(struct net_device *netdev, 617 struct ethtool_ringparam *ring) 618 { 619 struct e1000_adapter *adapter = netdev_priv(netdev); 620 struct e1000_ring *temp_tx = NULL, *temp_rx = NULL; 621 int err = 0, size = sizeof(struct e1000_ring); 622 bool set_tx = false, set_rx = false; 623 u16 new_rx_count, new_tx_count; 624 625 if ((ring->rx_mini_pending) || (ring->rx_jumbo_pending)) 626 return -EINVAL; 627 628 new_rx_count = clamp_t(u32, ring->rx_pending, E1000_MIN_RXD, 629 E1000_MAX_RXD); 630 new_rx_count = ALIGN(new_rx_count, REQ_RX_DESCRIPTOR_MULTIPLE); 631 632 new_tx_count = clamp_t(u32, ring->tx_pending, E1000_MIN_TXD, 633 E1000_MAX_TXD); 634 new_tx_count = ALIGN(new_tx_count, REQ_TX_DESCRIPTOR_MULTIPLE); 635 636 if ((new_tx_count == adapter->tx_ring_count) && 637 (new_rx_count == adapter->rx_ring_count)) 638 /* nothing to do */ 639 return 0; 640 641 while (test_and_set_bit(__E1000_RESETTING, &adapter->state)) 642 usleep_range(1000, 2000); 643 644 if (!netif_running(adapter->netdev)) { 645 /* Set counts now and allocate resources during open() */ 646 adapter->tx_ring->count = new_tx_count; 647 adapter->rx_ring->count = new_rx_count; 648 adapter->tx_ring_count = new_tx_count; 649 adapter->rx_ring_count = new_rx_count; 650 goto clear_reset; 651 } 652 653 set_tx = (new_tx_count != adapter->tx_ring_count); 654 set_rx = (new_rx_count != adapter->rx_ring_count); 655 656 /* Allocate temporary storage for ring updates */ 657 if (set_tx) { 658 temp_tx = vmalloc(size); 659 if (!temp_tx) { 660 err = -ENOMEM; 661 goto free_temp; 662 } 663 } 664 if (set_rx) { 665 temp_rx = vmalloc(size); 666 if (!temp_rx) { 667 err = -ENOMEM; 668 goto free_temp; 669 } 670 } 671 672 e1000e_down(adapter); 673 674 /* 675 * We can't just free everything and then setup again, because the 676 * ISRs in MSI-X mode get passed pointers to the Tx and Rx ring 677 * structs. First, attempt to allocate new resources... 678 */ 679 if (set_tx) { 680 memcpy(temp_tx, adapter->tx_ring, size); 681 temp_tx->count = new_tx_count; 682 err = e1000e_setup_tx_resources(temp_tx); 683 if (err) 684 goto err_setup; 685 } 686 if (set_rx) { 687 memcpy(temp_rx, adapter->rx_ring, size); 688 temp_rx->count = new_rx_count; 689 err = e1000e_setup_rx_resources(temp_rx); 690 if (err) 691 goto err_setup_rx; 692 } 693 694 /* ...then free the old resources and copy back any new ring data */ 695 if (set_tx) { 696 e1000e_free_tx_resources(adapter->tx_ring); 697 memcpy(adapter->tx_ring, temp_tx, size); 698 adapter->tx_ring_count = new_tx_count; 699 } 700 if (set_rx) { 701 e1000e_free_rx_resources(adapter->rx_ring); 702 memcpy(adapter->rx_ring, temp_rx, size); 703 adapter->rx_ring_count = new_rx_count; 704 } 705 706 err_setup_rx: 707 if (err && set_tx) 708 e1000e_free_tx_resources(temp_tx); 709 err_setup: 710 e1000e_up(adapter); 711 free_temp: 712 vfree(temp_tx); 713 vfree(temp_rx); 714 clear_reset: 715 clear_bit(__E1000_RESETTING, &adapter->state); 716 return err; 717 } 718 719 static bool reg_pattern_test(struct e1000_adapter *adapter, u64 *data, 720 int reg, int offset, u32 mask, u32 write) 721 { 722 u32 pat, val; 723 static const u32 test[] = { 724 0x5A5A5A5A, 0xA5A5A5A5, 0x00000000, 0xFFFFFFFF}; 725 for (pat = 0; pat < ARRAY_SIZE(test); pat++) { 726 E1000_WRITE_REG_ARRAY(&adapter->hw, reg, offset, 727 (test[pat] & write)); 728 val = E1000_READ_REG_ARRAY(&adapter->hw, reg, offset); 729 if (val != (test[pat] & write & mask)) { 730 e_err("pattern test reg %04X failed: got 0x%08X expected 0x%08X\n", 731 reg + offset, val, (test[pat] & write & mask)); 732 *data = reg; 733 return 1; 734 } 735 } 736 return 0; 737 } 738 739 static bool reg_set_and_check(struct e1000_adapter *adapter, u64 *data, 740 int reg, u32 mask, u32 write) 741 { 742 u32 val; 743 __ew32(&adapter->hw, reg, write & mask); 744 val = __er32(&adapter->hw, reg); 745 if ((write & mask) != (val & mask)) { 746 e_err("set/check reg %04X test failed: got 0x%08X expected 0x%08X\n", 747 reg, (val & mask), (write & mask)); 748 *data = reg; 749 return 1; 750 } 751 return 0; 752 } 753 #define REG_PATTERN_TEST_ARRAY(reg, offset, mask, write) \ 754 do { \ 755 if (reg_pattern_test(adapter, data, reg, offset, mask, write)) \ 756 return 1; \ 757 } while (0) 758 #define REG_PATTERN_TEST(reg, mask, write) \ 759 REG_PATTERN_TEST_ARRAY(reg, 0, mask, write) 760 761 #define REG_SET_AND_CHECK(reg, mask, write) \ 762 do { \ 763 if (reg_set_and_check(adapter, data, reg, mask, write)) \ 764 return 1; \ 765 } while (0) 766 767 static int e1000_reg_test(struct e1000_adapter *adapter, u64 *data) 768 { 769 struct e1000_hw *hw = &adapter->hw; 770 struct e1000_mac_info *mac = &adapter->hw.mac; 771 u32 value; 772 u32 before; 773 u32 after; 774 u32 i; 775 u32 toggle; 776 u32 mask; 777 u32 wlock_mac = 0; 778 779 /* 780 * The status register is Read Only, so a write should fail. 781 * Some bits that get toggled are ignored. 782 */ 783 switch (mac->type) { 784 /* there are several bits on newer hardware that are r/w */ 785 case e1000_82571: 786 case e1000_82572: 787 case e1000_80003es2lan: 788 toggle = 0x7FFFF3FF; 789 break; 790 default: 791 toggle = 0x7FFFF033; 792 break; 793 } 794 795 before = er32(STATUS); 796 value = (er32(STATUS) & toggle); 797 ew32(STATUS, toggle); 798 after = er32(STATUS) & toggle; 799 if (value != after) { 800 e_err("failed STATUS register test got: 0x%08X expected: 0x%08X\n", 801 after, value); 802 *data = 1; 803 return 1; 804 } 805 /* restore previous status */ 806 ew32(STATUS, before); 807 808 if (!(adapter->flags & FLAG_IS_ICH)) { 809 REG_PATTERN_TEST(E1000_FCAL, 0xFFFFFFFF, 0xFFFFFFFF); 810 REG_PATTERN_TEST(E1000_FCAH, 0x0000FFFF, 0xFFFFFFFF); 811 REG_PATTERN_TEST(E1000_FCT, 0x0000FFFF, 0xFFFFFFFF); 812 REG_PATTERN_TEST(E1000_VET, 0x0000FFFF, 0xFFFFFFFF); 813 } 814 815 REG_PATTERN_TEST(E1000_RDTR, 0x0000FFFF, 0xFFFFFFFF); 816 REG_PATTERN_TEST(E1000_RDBAH(0), 0xFFFFFFFF, 0xFFFFFFFF); 817 REG_PATTERN_TEST(E1000_RDLEN(0), 0x000FFF80, 0x000FFFFF); 818 REG_PATTERN_TEST(E1000_RDH(0), 0x0000FFFF, 0x0000FFFF); 819 REG_PATTERN_TEST(E1000_RDT(0), 0x0000FFFF, 0x0000FFFF); 820 REG_PATTERN_TEST(E1000_FCRTH, 0x0000FFF8, 0x0000FFF8); 821 REG_PATTERN_TEST(E1000_FCTTV, 0x0000FFFF, 0x0000FFFF); 822 REG_PATTERN_TEST(E1000_TIPG, 0x3FFFFFFF, 0x3FFFFFFF); 823 REG_PATTERN_TEST(E1000_TDBAH(0), 0xFFFFFFFF, 0xFFFFFFFF); 824 REG_PATTERN_TEST(E1000_TDLEN(0), 0x000FFF80, 0x000FFFFF); 825 826 REG_SET_AND_CHECK(E1000_RCTL, 0xFFFFFFFF, 0x00000000); 827 828 before = ((adapter->flags & FLAG_IS_ICH) ? 0x06C3B33E : 0x06DFB3FE); 829 REG_SET_AND_CHECK(E1000_RCTL, before, 0x003FFFFB); 830 REG_SET_AND_CHECK(E1000_TCTL, 0xFFFFFFFF, 0x00000000); 831 832 REG_SET_AND_CHECK(E1000_RCTL, before, 0xFFFFFFFF); 833 REG_PATTERN_TEST(E1000_RDBAL(0), 0xFFFFFFF0, 0xFFFFFFFF); 834 if (!(adapter->flags & FLAG_IS_ICH)) 835 REG_PATTERN_TEST(E1000_TXCW, 0xC000FFFF, 0x0000FFFF); 836 REG_PATTERN_TEST(E1000_TDBAL(0), 0xFFFFFFF0, 0xFFFFFFFF); 837 REG_PATTERN_TEST(E1000_TIDV, 0x0000FFFF, 0x0000FFFF); 838 mask = 0x8003FFFF; 839 switch (mac->type) { 840 case e1000_ich10lan: 841 case e1000_pchlan: 842 case e1000_pch2lan: 843 case e1000_pch_lpt: 844 mask |= (1 << 18); 845 break; 846 default: 847 break; 848 } 849 850 if (mac->type == e1000_pch_lpt) 851 wlock_mac = (er32(FWSM) & E1000_FWSM_WLOCK_MAC_MASK) >> 852 E1000_FWSM_WLOCK_MAC_SHIFT; 853 854 for (i = 0; i < mac->rar_entry_count; i++) { 855 /* Cannot test write-protected SHRAL[n] registers */ 856 if ((wlock_mac == 1) || (wlock_mac && (i > wlock_mac))) 857 continue; 858 859 REG_PATTERN_TEST_ARRAY(E1000_RA, ((i << 1) + 1), 860 mask, 0xFFFFFFFF); 861 } 862 863 for (i = 0; i < mac->mta_reg_count; i++) 864 REG_PATTERN_TEST_ARRAY(E1000_MTA, i, 0xFFFFFFFF, 0xFFFFFFFF); 865 866 *data = 0; 867 868 return 0; 869 } 870 871 static int e1000_eeprom_test(struct e1000_adapter *adapter, u64 *data) 872 { 873 u16 temp; 874 u16 checksum = 0; 875 u16 i; 876 877 *data = 0; 878 /* Read and add up the contents of the EEPROM */ 879 for (i = 0; i < (NVM_CHECKSUM_REG + 1); i++) { 880 if ((e1000_read_nvm(&adapter->hw, i, 1, &temp)) < 0) { 881 *data = 1; 882 return *data; 883 } 884 checksum += temp; 885 } 886 887 /* If Checksum is not Correct return error else test passed */ 888 if ((checksum != (u16) NVM_SUM) && !(*data)) 889 *data = 2; 890 891 return *data; 892 } 893 894 static irqreturn_t e1000_test_intr(int irq, void *data) 895 { 896 struct net_device *netdev = (struct net_device *) data; 897 struct e1000_adapter *adapter = netdev_priv(netdev); 898 struct e1000_hw *hw = &adapter->hw; 899 900 adapter->test_icr |= er32(ICR); 901 902 return IRQ_HANDLED; 903 } 904 905 static int e1000_intr_test(struct e1000_adapter *adapter, u64 *data) 906 { 907 struct net_device *netdev = adapter->netdev; 908 struct e1000_hw *hw = &adapter->hw; 909 u32 mask; 910 u32 shared_int = 1; 911 u32 irq = adapter->pdev->irq; 912 int i; 913 int ret_val = 0; 914 int int_mode = E1000E_INT_MODE_LEGACY; 915 916 *data = 0; 917 918 /* NOTE: we don't test MSI/MSI-X interrupts here, yet */ 919 if (adapter->int_mode == E1000E_INT_MODE_MSIX) { 920 int_mode = adapter->int_mode; 921 e1000e_reset_interrupt_capability(adapter); 922 adapter->int_mode = E1000E_INT_MODE_LEGACY; 923 e1000e_set_interrupt_capability(adapter); 924 } 925 /* Hook up test interrupt handler just for this test */ 926 if (!request_irq(irq, e1000_test_intr, IRQF_PROBE_SHARED, netdev->name, 927 netdev)) { 928 shared_int = 0; 929 } else if (request_irq(irq, e1000_test_intr, IRQF_SHARED, 930 netdev->name, netdev)) { 931 *data = 1; 932 ret_val = -1; 933 goto out; 934 } 935 e_info("testing %s interrupt\n", (shared_int ? "shared" : "unshared")); 936 937 /* Disable all the interrupts */ 938 ew32(IMC, 0xFFFFFFFF); 939 e1e_flush(); 940 usleep_range(10000, 20000); 941 942 /* Test each interrupt */ 943 for (i = 0; i < 10; i++) { 944 /* Interrupt to test */ 945 mask = 1 << i; 946 947 if (adapter->flags & FLAG_IS_ICH) { 948 switch (mask) { 949 case E1000_ICR_RXSEQ: 950 continue; 951 case 0x00000100: 952 if (adapter->hw.mac.type == e1000_ich8lan || 953 adapter->hw.mac.type == e1000_ich9lan) 954 continue; 955 break; 956 default: 957 break; 958 } 959 } 960 961 if (!shared_int) { 962 /* 963 * Disable the interrupt to be reported in 964 * the cause register and then force the same 965 * interrupt and see if one gets posted. If 966 * an interrupt was posted to the bus, the 967 * test failed. 968 */ 969 adapter->test_icr = 0; 970 ew32(IMC, mask); 971 ew32(ICS, mask); 972 e1e_flush(); 973 usleep_range(10000, 20000); 974 975 if (adapter->test_icr & mask) { 976 *data = 3; 977 break; 978 } 979 } 980 981 /* 982 * Enable the interrupt to be reported in 983 * the cause register and then force the same 984 * interrupt and see if one gets posted. If 985 * an interrupt was not posted to the bus, the 986 * test failed. 987 */ 988 adapter->test_icr = 0; 989 ew32(IMS, mask); 990 ew32(ICS, mask); 991 e1e_flush(); 992 usleep_range(10000, 20000); 993 994 if (!(adapter->test_icr & mask)) { 995 *data = 4; 996 break; 997 } 998 999 if (!shared_int) { 1000 /* 1001 * Disable the other interrupts to be reported in 1002 * the cause register and then force the other 1003 * interrupts and see if any get posted. If 1004 * an interrupt was posted to the bus, the 1005 * test failed. 1006 */ 1007 adapter->test_icr = 0; 1008 ew32(IMC, ~mask & 0x00007FFF); 1009 ew32(ICS, ~mask & 0x00007FFF); 1010 e1e_flush(); 1011 usleep_range(10000, 20000); 1012 1013 if (adapter->test_icr) { 1014 *data = 5; 1015 break; 1016 } 1017 } 1018 } 1019 1020 /* Disable all the interrupts */ 1021 ew32(IMC, 0xFFFFFFFF); 1022 e1e_flush(); 1023 usleep_range(10000, 20000); 1024 1025 /* Unhook test interrupt handler */ 1026 free_irq(irq, netdev); 1027 1028 out: 1029 if (int_mode == E1000E_INT_MODE_MSIX) { 1030 e1000e_reset_interrupt_capability(adapter); 1031 adapter->int_mode = int_mode; 1032 e1000e_set_interrupt_capability(adapter); 1033 } 1034 1035 return ret_val; 1036 } 1037 1038 static void e1000_free_desc_rings(struct e1000_adapter *adapter) 1039 { 1040 struct e1000_ring *tx_ring = &adapter->test_tx_ring; 1041 struct e1000_ring *rx_ring = &adapter->test_rx_ring; 1042 struct pci_dev *pdev = adapter->pdev; 1043 int i; 1044 1045 if (tx_ring->desc && tx_ring->buffer_info) { 1046 for (i = 0; i < tx_ring->count; i++) { 1047 if (tx_ring->buffer_info[i].dma) 1048 dma_unmap_single(&pdev->dev, 1049 tx_ring->buffer_info[i].dma, 1050 tx_ring->buffer_info[i].length, 1051 DMA_TO_DEVICE); 1052 if (tx_ring->buffer_info[i].skb) 1053 dev_kfree_skb(tx_ring->buffer_info[i].skb); 1054 } 1055 } 1056 1057 if (rx_ring->desc && rx_ring->buffer_info) { 1058 for (i = 0; i < rx_ring->count; i++) { 1059 if (rx_ring->buffer_info[i].dma) 1060 dma_unmap_single(&pdev->dev, 1061 rx_ring->buffer_info[i].dma, 1062 2048, DMA_FROM_DEVICE); 1063 if (rx_ring->buffer_info[i].skb) 1064 dev_kfree_skb(rx_ring->buffer_info[i].skb); 1065 } 1066 } 1067 1068 if (tx_ring->desc) { 1069 dma_free_coherent(&pdev->dev, tx_ring->size, tx_ring->desc, 1070 tx_ring->dma); 1071 tx_ring->desc = NULL; 1072 } 1073 if (rx_ring->desc) { 1074 dma_free_coherent(&pdev->dev, rx_ring->size, rx_ring->desc, 1075 rx_ring->dma); 1076 rx_ring->desc = NULL; 1077 } 1078 1079 kfree(tx_ring->buffer_info); 1080 tx_ring->buffer_info = NULL; 1081 kfree(rx_ring->buffer_info); 1082 rx_ring->buffer_info = NULL; 1083 } 1084 1085 static int e1000_setup_desc_rings(struct e1000_adapter *adapter) 1086 { 1087 struct e1000_ring *tx_ring = &adapter->test_tx_ring; 1088 struct e1000_ring *rx_ring = &adapter->test_rx_ring; 1089 struct pci_dev *pdev = adapter->pdev; 1090 struct e1000_hw *hw = &adapter->hw; 1091 u32 rctl; 1092 int i; 1093 int ret_val; 1094 1095 /* Setup Tx descriptor ring and Tx buffers */ 1096 1097 if (!tx_ring->count) 1098 tx_ring->count = E1000_DEFAULT_TXD; 1099 1100 tx_ring->buffer_info = kcalloc(tx_ring->count, 1101 sizeof(struct e1000_buffer), 1102 GFP_KERNEL); 1103 if (!tx_ring->buffer_info) { 1104 ret_val = 1; 1105 goto err_nomem; 1106 } 1107 1108 tx_ring->size = tx_ring->count * sizeof(struct e1000_tx_desc); 1109 tx_ring->size = ALIGN(tx_ring->size, 4096); 1110 tx_ring->desc = dma_alloc_coherent(&pdev->dev, tx_ring->size, 1111 &tx_ring->dma, GFP_KERNEL); 1112 if (!tx_ring->desc) { 1113 ret_val = 2; 1114 goto err_nomem; 1115 } 1116 tx_ring->next_to_use = 0; 1117 tx_ring->next_to_clean = 0; 1118 1119 ew32(TDBAL(0), ((u64) tx_ring->dma & 0x00000000FFFFFFFF)); 1120 ew32(TDBAH(0), ((u64) tx_ring->dma >> 32)); 1121 ew32(TDLEN(0), tx_ring->count * sizeof(struct e1000_tx_desc)); 1122 ew32(TDH(0), 0); 1123 ew32(TDT(0), 0); 1124 ew32(TCTL, E1000_TCTL_PSP | E1000_TCTL_EN | E1000_TCTL_MULR | 1125 E1000_COLLISION_THRESHOLD << E1000_CT_SHIFT | 1126 E1000_COLLISION_DISTANCE << E1000_COLD_SHIFT); 1127 1128 for (i = 0; i < tx_ring->count; i++) { 1129 struct e1000_tx_desc *tx_desc = E1000_TX_DESC(*tx_ring, i); 1130 struct sk_buff *skb; 1131 unsigned int skb_size = 1024; 1132 1133 skb = alloc_skb(skb_size, GFP_KERNEL); 1134 if (!skb) { 1135 ret_val = 3; 1136 goto err_nomem; 1137 } 1138 skb_put(skb, skb_size); 1139 tx_ring->buffer_info[i].skb = skb; 1140 tx_ring->buffer_info[i].length = skb->len; 1141 tx_ring->buffer_info[i].dma = 1142 dma_map_single(&pdev->dev, skb->data, skb->len, 1143 DMA_TO_DEVICE); 1144 if (dma_mapping_error(&pdev->dev, 1145 tx_ring->buffer_info[i].dma)) { 1146 ret_val = 4; 1147 goto err_nomem; 1148 } 1149 tx_desc->buffer_addr = cpu_to_le64(tx_ring->buffer_info[i].dma); 1150 tx_desc->lower.data = cpu_to_le32(skb->len); 1151 tx_desc->lower.data |= cpu_to_le32(E1000_TXD_CMD_EOP | 1152 E1000_TXD_CMD_IFCS | 1153 E1000_TXD_CMD_RS); 1154 tx_desc->upper.data = 0; 1155 } 1156 1157 /* Setup Rx descriptor ring and Rx buffers */ 1158 1159 if (!rx_ring->count) 1160 rx_ring->count = E1000_DEFAULT_RXD; 1161 1162 rx_ring->buffer_info = kcalloc(rx_ring->count, 1163 sizeof(struct e1000_buffer), 1164 GFP_KERNEL); 1165 if (!rx_ring->buffer_info) { 1166 ret_val = 5; 1167 goto err_nomem; 1168 } 1169 1170 rx_ring->size = rx_ring->count * sizeof(union e1000_rx_desc_extended); 1171 rx_ring->desc = dma_alloc_coherent(&pdev->dev, rx_ring->size, 1172 &rx_ring->dma, GFP_KERNEL); 1173 if (!rx_ring->desc) { 1174 ret_val = 6; 1175 goto err_nomem; 1176 } 1177 rx_ring->next_to_use = 0; 1178 rx_ring->next_to_clean = 0; 1179 1180 rctl = er32(RCTL); 1181 if (!(adapter->flags2 & FLAG2_NO_DISABLE_RX)) 1182 ew32(RCTL, rctl & ~E1000_RCTL_EN); 1183 ew32(RDBAL(0), ((u64) rx_ring->dma & 0xFFFFFFFF)); 1184 ew32(RDBAH(0), ((u64) rx_ring->dma >> 32)); 1185 ew32(RDLEN(0), rx_ring->size); 1186 ew32(RDH(0), 0); 1187 ew32(RDT(0), 0); 1188 rctl = E1000_RCTL_EN | E1000_RCTL_BAM | E1000_RCTL_SZ_2048 | 1189 E1000_RCTL_UPE | E1000_RCTL_MPE | E1000_RCTL_LPE | 1190 E1000_RCTL_SBP | E1000_RCTL_SECRC | 1191 E1000_RCTL_LBM_NO | E1000_RCTL_RDMTS_HALF | 1192 (adapter->hw.mac.mc_filter_type << E1000_RCTL_MO_SHIFT); 1193 ew32(RCTL, rctl); 1194 1195 for (i = 0; i < rx_ring->count; i++) { 1196 union e1000_rx_desc_extended *rx_desc; 1197 struct sk_buff *skb; 1198 1199 skb = alloc_skb(2048 + NET_IP_ALIGN, GFP_KERNEL); 1200 if (!skb) { 1201 ret_val = 7; 1202 goto err_nomem; 1203 } 1204 skb_reserve(skb, NET_IP_ALIGN); 1205 rx_ring->buffer_info[i].skb = skb; 1206 rx_ring->buffer_info[i].dma = 1207 dma_map_single(&pdev->dev, skb->data, 2048, 1208 DMA_FROM_DEVICE); 1209 if (dma_mapping_error(&pdev->dev, 1210 rx_ring->buffer_info[i].dma)) { 1211 ret_val = 8; 1212 goto err_nomem; 1213 } 1214 rx_desc = E1000_RX_DESC_EXT(*rx_ring, i); 1215 rx_desc->read.buffer_addr = 1216 cpu_to_le64(rx_ring->buffer_info[i].dma); 1217 memset(skb->data, 0x00, skb->len); 1218 } 1219 1220 return 0; 1221 1222 err_nomem: 1223 e1000_free_desc_rings(adapter); 1224 return ret_val; 1225 } 1226 1227 static void e1000_phy_disable_receiver(struct e1000_adapter *adapter) 1228 { 1229 /* Write out to PHY registers 29 and 30 to disable the Receiver. */ 1230 e1e_wphy(&adapter->hw, 29, 0x001F); 1231 e1e_wphy(&adapter->hw, 30, 0x8FFC); 1232 e1e_wphy(&adapter->hw, 29, 0x001A); 1233 e1e_wphy(&adapter->hw, 30, 0x8FF0); 1234 } 1235 1236 static int e1000_integrated_phy_loopback(struct e1000_adapter *adapter) 1237 { 1238 struct e1000_hw *hw = &adapter->hw; 1239 u32 ctrl_reg = 0; 1240 u16 phy_reg = 0; 1241 s32 ret_val = 0; 1242 1243 hw->mac.autoneg = 0; 1244 1245 if (hw->phy.type == e1000_phy_ife) { 1246 /* force 100, set loopback */ 1247 e1e_wphy(hw, PHY_CONTROL, 0x6100); 1248 1249 /* Now set up the MAC to the same speed/duplex as the PHY. */ 1250 ctrl_reg = er32(CTRL); 1251 ctrl_reg &= ~E1000_CTRL_SPD_SEL; /* Clear the speed sel bits */ 1252 ctrl_reg |= (E1000_CTRL_FRCSPD | /* Set the Force Speed Bit */ 1253 E1000_CTRL_FRCDPX | /* Set the Force Duplex Bit */ 1254 E1000_CTRL_SPD_100 |/* Force Speed to 100 */ 1255 E1000_CTRL_FD); /* Force Duplex to FULL */ 1256 1257 ew32(CTRL, ctrl_reg); 1258 e1e_flush(); 1259 udelay(500); 1260 1261 return 0; 1262 } 1263 1264 /* Specific PHY configuration for loopback */ 1265 switch (hw->phy.type) { 1266 case e1000_phy_m88: 1267 /* Auto-MDI/MDIX Off */ 1268 e1e_wphy(hw, M88E1000_PHY_SPEC_CTRL, 0x0808); 1269 /* reset to update Auto-MDI/MDIX */ 1270 e1e_wphy(hw, PHY_CONTROL, 0x9140); 1271 /* autoneg off */ 1272 e1e_wphy(hw, PHY_CONTROL, 0x8140); 1273 break; 1274 case e1000_phy_gg82563: 1275 e1e_wphy(hw, GG82563_PHY_KMRN_MODE_CTRL, 0x1CC); 1276 break; 1277 case e1000_phy_bm: 1278 /* Set Default MAC Interface speed to 1GB */ 1279 e1e_rphy(hw, PHY_REG(2, 21), &phy_reg); 1280 phy_reg &= ~0x0007; 1281 phy_reg |= 0x006; 1282 e1e_wphy(hw, PHY_REG(2, 21), phy_reg); 1283 /* Assert SW reset for above settings to take effect */ 1284 e1000e_commit_phy(hw); 1285 mdelay(1); 1286 /* Force Full Duplex */ 1287 e1e_rphy(hw, PHY_REG(769, 16), &phy_reg); 1288 e1e_wphy(hw, PHY_REG(769, 16), phy_reg | 0x000C); 1289 /* Set Link Up (in force link) */ 1290 e1e_rphy(hw, PHY_REG(776, 16), &phy_reg); 1291 e1e_wphy(hw, PHY_REG(776, 16), phy_reg | 0x0040); 1292 /* Force Link */ 1293 e1e_rphy(hw, PHY_REG(769, 16), &phy_reg); 1294 e1e_wphy(hw, PHY_REG(769, 16), phy_reg | 0x0040); 1295 /* Set Early Link Enable */ 1296 e1e_rphy(hw, PHY_REG(769, 20), &phy_reg); 1297 e1e_wphy(hw, PHY_REG(769, 20), phy_reg | 0x0400); 1298 break; 1299 case e1000_phy_82577: 1300 case e1000_phy_82578: 1301 /* Workaround: K1 must be disabled for stable 1Gbps operation */ 1302 ret_val = hw->phy.ops.acquire(hw); 1303 if (ret_val) { 1304 e_err("Cannot setup 1Gbps loopback.\n"); 1305 return ret_val; 1306 } 1307 e1000_configure_k1_ich8lan(hw, false); 1308 hw->phy.ops.release(hw); 1309 break; 1310 case e1000_phy_82579: 1311 /* Disable PHY energy detect power down */ 1312 e1e_rphy(hw, PHY_REG(0, 21), &phy_reg); 1313 e1e_wphy(hw, PHY_REG(0, 21), phy_reg & ~(1 << 3)); 1314 /* Disable full chip energy detect */ 1315 e1e_rphy(hw, PHY_REG(776, 18), &phy_reg); 1316 e1e_wphy(hw, PHY_REG(776, 18), phy_reg | 1); 1317 /* Enable loopback on the PHY */ 1318 #define I82577_PHY_LBK_CTRL 19 1319 e1e_wphy(hw, I82577_PHY_LBK_CTRL, 0x8001); 1320 break; 1321 default: 1322 break; 1323 } 1324 1325 /* force 1000, set loopback */ 1326 e1e_wphy(hw, PHY_CONTROL, 0x4140); 1327 mdelay(250); 1328 1329 /* Now set up the MAC to the same speed/duplex as the PHY. */ 1330 ctrl_reg = er32(CTRL); 1331 ctrl_reg &= ~E1000_CTRL_SPD_SEL; /* Clear the speed sel bits */ 1332 ctrl_reg |= (E1000_CTRL_FRCSPD | /* Set the Force Speed Bit */ 1333 E1000_CTRL_FRCDPX | /* Set the Force Duplex Bit */ 1334 E1000_CTRL_SPD_1000 |/* Force Speed to 1000 */ 1335 E1000_CTRL_FD); /* Force Duplex to FULL */ 1336 1337 if (adapter->flags & FLAG_IS_ICH) 1338 ctrl_reg |= E1000_CTRL_SLU; /* Set Link Up */ 1339 1340 if (hw->phy.media_type == e1000_media_type_copper && 1341 hw->phy.type == e1000_phy_m88) { 1342 ctrl_reg |= E1000_CTRL_ILOS; /* Invert Loss of Signal */ 1343 } else { 1344 /* 1345 * Set the ILOS bit on the fiber Nic if half duplex link is 1346 * detected. 1347 */ 1348 if ((er32(STATUS) & E1000_STATUS_FD) == 0) 1349 ctrl_reg |= (E1000_CTRL_ILOS | E1000_CTRL_SLU); 1350 } 1351 1352 ew32(CTRL, ctrl_reg); 1353 1354 /* 1355 * Disable the receiver on the PHY so when a cable is plugged in, the 1356 * PHY does not begin to autoneg when a cable is reconnected to the NIC. 1357 */ 1358 if (hw->phy.type == e1000_phy_m88) 1359 e1000_phy_disable_receiver(adapter); 1360 1361 udelay(500); 1362 1363 return 0; 1364 } 1365 1366 static int e1000_set_82571_fiber_loopback(struct e1000_adapter *adapter) 1367 { 1368 struct e1000_hw *hw = &adapter->hw; 1369 u32 ctrl = er32(CTRL); 1370 int link = 0; 1371 1372 /* special requirements for 82571/82572 fiber adapters */ 1373 1374 /* 1375 * jump through hoops to make sure link is up because serdes 1376 * link is hardwired up 1377 */ 1378 ctrl |= E1000_CTRL_SLU; 1379 ew32(CTRL, ctrl); 1380 1381 /* disable autoneg */ 1382 ctrl = er32(TXCW); 1383 ctrl &= ~(1 << 31); 1384 ew32(TXCW, ctrl); 1385 1386 link = (er32(STATUS) & E1000_STATUS_LU); 1387 1388 if (!link) { 1389 /* set invert loss of signal */ 1390 ctrl = er32(CTRL); 1391 ctrl |= E1000_CTRL_ILOS; 1392 ew32(CTRL, ctrl); 1393 } 1394 1395 /* 1396 * special write to serdes control register to enable SerDes analog 1397 * loopback 1398 */ 1399 #define E1000_SERDES_LB_ON 0x410 1400 ew32(SCTL, E1000_SERDES_LB_ON); 1401 e1e_flush(); 1402 usleep_range(10000, 20000); 1403 1404 return 0; 1405 } 1406 1407 /* only call this for fiber/serdes connections to es2lan */ 1408 static int e1000_set_es2lan_mac_loopback(struct e1000_adapter *adapter) 1409 { 1410 struct e1000_hw *hw = &adapter->hw; 1411 u32 ctrlext = er32(CTRL_EXT); 1412 u32 ctrl = er32(CTRL); 1413 1414 /* 1415 * save CTRL_EXT to restore later, reuse an empty variable (unused 1416 * on mac_type 80003es2lan) 1417 */ 1418 adapter->tx_fifo_head = ctrlext; 1419 1420 /* clear the serdes mode bits, putting the device into mac loopback */ 1421 ctrlext &= ~E1000_CTRL_EXT_LINK_MODE_PCIE_SERDES; 1422 ew32(CTRL_EXT, ctrlext); 1423 1424 /* force speed to 1000/FD, link up */ 1425 ctrl &= ~(E1000_CTRL_SPD_1000 | E1000_CTRL_SPD_100); 1426 ctrl |= (E1000_CTRL_SLU | E1000_CTRL_FRCSPD | E1000_CTRL_FRCDPX | 1427 E1000_CTRL_SPD_1000 | E1000_CTRL_FD); 1428 ew32(CTRL, ctrl); 1429 1430 /* set mac loopback */ 1431 ctrl = er32(RCTL); 1432 ctrl |= E1000_RCTL_LBM_MAC; 1433 ew32(RCTL, ctrl); 1434 1435 /* set testing mode parameters (no need to reset later) */ 1436 #define KMRNCTRLSTA_OPMODE (0x1F << 16) 1437 #define KMRNCTRLSTA_OPMODE_1GB_FD_GMII 0x0582 1438 ew32(KMRNCTRLSTA, 1439 (KMRNCTRLSTA_OPMODE | KMRNCTRLSTA_OPMODE_1GB_FD_GMII)); 1440 1441 return 0; 1442 } 1443 1444 static int e1000_setup_loopback_test(struct e1000_adapter *adapter) 1445 { 1446 struct e1000_hw *hw = &adapter->hw; 1447 u32 rctl; 1448 1449 if (hw->phy.media_type == e1000_media_type_fiber || 1450 hw->phy.media_type == e1000_media_type_internal_serdes) { 1451 switch (hw->mac.type) { 1452 case e1000_80003es2lan: 1453 return e1000_set_es2lan_mac_loopback(adapter); 1454 break; 1455 case e1000_82571: 1456 case e1000_82572: 1457 return e1000_set_82571_fiber_loopback(adapter); 1458 break; 1459 default: 1460 rctl = er32(RCTL); 1461 rctl |= E1000_RCTL_LBM_TCVR; 1462 ew32(RCTL, rctl); 1463 return 0; 1464 } 1465 } else if (hw->phy.media_type == e1000_media_type_copper) { 1466 return e1000_integrated_phy_loopback(adapter); 1467 } 1468 1469 return 7; 1470 } 1471 1472 static void e1000_loopback_cleanup(struct e1000_adapter *adapter) 1473 { 1474 struct e1000_hw *hw = &adapter->hw; 1475 u32 rctl; 1476 u16 phy_reg; 1477 1478 rctl = er32(RCTL); 1479 rctl &= ~(E1000_RCTL_LBM_TCVR | E1000_RCTL_LBM_MAC); 1480 ew32(RCTL, rctl); 1481 1482 switch (hw->mac.type) { 1483 case e1000_80003es2lan: 1484 if (hw->phy.media_type == e1000_media_type_fiber || 1485 hw->phy.media_type == e1000_media_type_internal_serdes) { 1486 /* restore CTRL_EXT, stealing space from tx_fifo_head */ 1487 ew32(CTRL_EXT, adapter->tx_fifo_head); 1488 adapter->tx_fifo_head = 0; 1489 } 1490 /* fall through */ 1491 case e1000_82571: 1492 case e1000_82572: 1493 if (hw->phy.media_type == e1000_media_type_fiber || 1494 hw->phy.media_type == e1000_media_type_internal_serdes) { 1495 #define E1000_SERDES_LB_OFF 0x400 1496 ew32(SCTL, E1000_SERDES_LB_OFF); 1497 e1e_flush(); 1498 usleep_range(10000, 20000); 1499 break; 1500 } 1501 /* Fall Through */ 1502 default: 1503 hw->mac.autoneg = 1; 1504 if (hw->phy.type == e1000_phy_gg82563) 1505 e1e_wphy(hw, GG82563_PHY_KMRN_MODE_CTRL, 0x180); 1506 e1e_rphy(hw, PHY_CONTROL, &phy_reg); 1507 if (phy_reg & MII_CR_LOOPBACK) { 1508 phy_reg &= ~MII_CR_LOOPBACK; 1509 e1e_wphy(hw, PHY_CONTROL, phy_reg); 1510 e1000e_commit_phy(hw); 1511 } 1512 break; 1513 } 1514 } 1515 1516 static void e1000_create_lbtest_frame(struct sk_buff *skb, 1517 unsigned int frame_size) 1518 { 1519 memset(skb->data, 0xFF, frame_size); 1520 frame_size &= ~1; 1521 memset(&skb->data[frame_size / 2], 0xAA, frame_size / 2 - 1); 1522 memset(&skb->data[frame_size / 2 + 10], 0xBE, 1); 1523 memset(&skb->data[frame_size / 2 + 12], 0xAF, 1); 1524 } 1525 1526 static int e1000_check_lbtest_frame(struct sk_buff *skb, 1527 unsigned int frame_size) 1528 { 1529 frame_size &= ~1; 1530 if (*(skb->data + 3) == 0xFF) 1531 if ((*(skb->data + frame_size / 2 + 10) == 0xBE) && 1532 (*(skb->data + frame_size / 2 + 12) == 0xAF)) 1533 return 0; 1534 return 13; 1535 } 1536 1537 static int e1000_run_loopback_test(struct e1000_adapter *adapter) 1538 { 1539 struct e1000_ring *tx_ring = &adapter->test_tx_ring; 1540 struct e1000_ring *rx_ring = &adapter->test_rx_ring; 1541 struct pci_dev *pdev = adapter->pdev; 1542 struct e1000_hw *hw = &adapter->hw; 1543 int i, j, k, l; 1544 int lc; 1545 int good_cnt; 1546 int ret_val = 0; 1547 unsigned long time; 1548 1549 ew32(RDT(0), rx_ring->count - 1); 1550 1551 /* 1552 * Calculate the loop count based on the largest descriptor ring 1553 * The idea is to wrap the largest ring a number of times using 64 1554 * send/receive pairs during each loop 1555 */ 1556 1557 if (rx_ring->count <= tx_ring->count) 1558 lc = ((tx_ring->count / 64) * 2) + 1; 1559 else 1560 lc = ((rx_ring->count / 64) * 2) + 1; 1561 1562 k = 0; 1563 l = 0; 1564 for (j = 0; j <= lc; j++) { /* loop count loop */ 1565 for (i = 0; i < 64; i++) { /* send the packets */ 1566 e1000_create_lbtest_frame(tx_ring->buffer_info[k].skb, 1567 1024); 1568 dma_sync_single_for_device(&pdev->dev, 1569 tx_ring->buffer_info[k].dma, 1570 tx_ring->buffer_info[k].length, 1571 DMA_TO_DEVICE); 1572 k++; 1573 if (k == tx_ring->count) 1574 k = 0; 1575 } 1576 ew32(TDT(0), k); 1577 e1e_flush(); 1578 msleep(200); 1579 time = jiffies; /* set the start time for the receive */ 1580 good_cnt = 0; 1581 do { /* receive the sent packets */ 1582 dma_sync_single_for_cpu(&pdev->dev, 1583 rx_ring->buffer_info[l].dma, 2048, 1584 DMA_FROM_DEVICE); 1585 1586 ret_val = e1000_check_lbtest_frame( 1587 rx_ring->buffer_info[l].skb, 1024); 1588 if (!ret_val) 1589 good_cnt++; 1590 l++; 1591 if (l == rx_ring->count) 1592 l = 0; 1593 /* 1594 * time + 20 msecs (200 msecs on 2.4) is more than 1595 * enough time to complete the receives, if it's 1596 * exceeded, break and error off 1597 */ 1598 } while ((good_cnt < 64) && !time_after(jiffies, time + 20)); 1599 if (good_cnt != 64) { 1600 ret_val = 13; /* ret_val is the same as mis-compare */ 1601 break; 1602 } 1603 if (jiffies >= (time + 20)) { 1604 ret_val = 14; /* error code for time out error */ 1605 break; 1606 } 1607 } /* end loop count loop */ 1608 return ret_val; 1609 } 1610 1611 static int e1000_loopback_test(struct e1000_adapter *adapter, u64 *data) 1612 { 1613 struct e1000_hw *hw = &adapter->hw; 1614 1615 /* 1616 * PHY loopback cannot be performed if SoL/IDER 1617 * sessions are active 1618 */ 1619 if (hw->phy.ops.check_reset_block && 1620 hw->phy.ops.check_reset_block(hw)) { 1621 e_err("Cannot do PHY loopback test when SoL/IDER is active.\n"); 1622 *data = 0; 1623 goto out; 1624 } 1625 1626 *data = e1000_setup_desc_rings(adapter); 1627 if (*data) 1628 goto out; 1629 1630 *data = e1000_setup_loopback_test(adapter); 1631 if (*data) 1632 goto err_loopback; 1633 1634 *data = e1000_run_loopback_test(adapter); 1635 e1000_loopback_cleanup(adapter); 1636 1637 err_loopback: 1638 e1000_free_desc_rings(adapter); 1639 out: 1640 return *data; 1641 } 1642 1643 static int e1000_link_test(struct e1000_adapter *adapter, u64 *data) 1644 { 1645 struct e1000_hw *hw = &adapter->hw; 1646 1647 *data = 0; 1648 if (hw->phy.media_type == e1000_media_type_internal_serdes) { 1649 int i = 0; 1650 hw->mac.serdes_has_link = false; 1651 1652 /* 1653 * On some blade server designs, link establishment 1654 * could take as long as 2-3 minutes 1655 */ 1656 do { 1657 hw->mac.ops.check_for_link(hw); 1658 if (hw->mac.serdes_has_link) 1659 return *data; 1660 msleep(20); 1661 } while (i++ < 3750); 1662 1663 *data = 1; 1664 } else { 1665 hw->mac.ops.check_for_link(hw); 1666 if (hw->mac.autoneg) 1667 /* 1668 * On some Phy/switch combinations, link establishment 1669 * can take a few seconds more than expected. 1670 */ 1671 msleep(5000); 1672 1673 if (!(er32(STATUS) & E1000_STATUS_LU)) 1674 *data = 1; 1675 } 1676 return *data; 1677 } 1678 1679 static int e1000e_get_sset_count(struct net_device *netdev, int sset) 1680 { 1681 switch (sset) { 1682 case ETH_SS_TEST: 1683 return E1000_TEST_LEN; 1684 case ETH_SS_STATS: 1685 return E1000_STATS_LEN; 1686 default: 1687 return -EOPNOTSUPP; 1688 } 1689 } 1690 1691 static void e1000_diag_test(struct net_device *netdev, 1692 struct ethtool_test *eth_test, u64 *data) 1693 { 1694 struct e1000_adapter *adapter = netdev_priv(netdev); 1695 u16 autoneg_advertised; 1696 u8 forced_speed_duplex; 1697 u8 autoneg; 1698 bool if_running = netif_running(netdev); 1699 1700 set_bit(__E1000_TESTING, &adapter->state); 1701 1702 if (!if_running) { 1703 /* Get control of and reset hardware */ 1704 if (adapter->flags & FLAG_HAS_AMT) 1705 e1000e_get_hw_control(adapter); 1706 1707 e1000e_power_up_phy(adapter); 1708 1709 adapter->hw.phy.autoneg_wait_to_complete = 1; 1710 e1000e_reset(adapter); 1711 adapter->hw.phy.autoneg_wait_to_complete = 0; 1712 } 1713 1714 if (eth_test->flags == ETH_TEST_FL_OFFLINE) { 1715 /* Offline tests */ 1716 1717 /* save speed, duplex, autoneg settings */ 1718 autoneg_advertised = adapter->hw.phy.autoneg_advertised; 1719 forced_speed_duplex = adapter->hw.mac.forced_speed_duplex; 1720 autoneg = adapter->hw.mac.autoneg; 1721 1722 e_info("offline testing starting\n"); 1723 1724 if (if_running) 1725 /* indicate we're in test mode */ 1726 dev_close(netdev); 1727 1728 if (e1000_reg_test(adapter, &data[0])) 1729 eth_test->flags |= ETH_TEST_FL_FAILED; 1730 1731 e1000e_reset(adapter); 1732 if (e1000_eeprom_test(adapter, &data[1])) 1733 eth_test->flags |= ETH_TEST_FL_FAILED; 1734 1735 e1000e_reset(adapter); 1736 if (e1000_intr_test(adapter, &data[2])) 1737 eth_test->flags |= ETH_TEST_FL_FAILED; 1738 1739 e1000e_reset(adapter); 1740 if (e1000_loopback_test(adapter, &data[3])) 1741 eth_test->flags |= ETH_TEST_FL_FAILED; 1742 1743 /* force this routine to wait until autoneg complete/timeout */ 1744 adapter->hw.phy.autoneg_wait_to_complete = 1; 1745 e1000e_reset(adapter); 1746 adapter->hw.phy.autoneg_wait_to_complete = 0; 1747 1748 if (e1000_link_test(adapter, &data[4])) 1749 eth_test->flags |= ETH_TEST_FL_FAILED; 1750 1751 /* restore speed, duplex, autoneg settings */ 1752 adapter->hw.phy.autoneg_advertised = autoneg_advertised; 1753 adapter->hw.mac.forced_speed_duplex = forced_speed_duplex; 1754 adapter->hw.mac.autoneg = autoneg; 1755 e1000e_reset(adapter); 1756 1757 clear_bit(__E1000_TESTING, &adapter->state); 1758 if (if_running) 1759 dev_open(netdev); 1760 } else { 1761 /* Online tests */ 1762 1763 e_info("online testing starting\n"); 1764 1765 /* register, eeprom, intr and loopback tests not run online */ 1766 data[0] = 0; 1767 data[1] = 0; 1768 data[2] = 0; 1769 data[3] = 0; 1770 1771 if (e1000_link_test(adapter, &data[4])) 1772 eth_test->flags |= ETH_TEST_FL_FAILED; 1773 1774 clear_bit(__E1000_TESTING, &adapter->state); 1775 } 1776 1777 if (!if_running) { 1778 e1000e_reset(adapter); 1779 1780 if (adapter->flags & FLAG_HAS_AMT) 1781 e1000e_release_hw_control(adapter); 1782 } 1783 1784 msleep_interruptible(4 * 1000); 1785 } 1786 1787 static void e1000_get_wol(struct net_device *netdev, 1788 struct ethtool_wolinfo *wol) 1789 { 1790 struct e1000_adapter *adapter = netdev_priv(netdev); 1791 1792 wol->supported = 0; 1793 wol->wolopts = 0; 1794 1795 if (!(adapter->flags & FLAG_HAS_WOL) || 1796 !device_can_wakeup(&adapter->pdev->dev)) 1797 return; 1798 1799 wol->supported = WAKE_UCAST | WAKE_MCAST | 1800 WAKE_BCAST | WAKE_MAGIC | WAKE_PHY; 1801 1802 /* apply any specific unsupported masks here */ 1803 if (adapter->flags & FLAG_NO_WAKE_UCAST) { 1804 wol->supported &= ~WAKE_UCAST; 1805 1806 if (adapter->wol & E1000_WUFC_EX) 1807 e_err("Interface does not support directed (unicast) frame wake-up packets\n"); 1808 } 1809 1810 if (adapter->wol & E1000_WUFC_EX) 1811 wol->wolopts |= WAKE_UCAST; 1812 if (adapter->wol & E1000_WUFC_MC) 1813 wol->wolopts |= WAKE_MCAST; 1814 if (adapter->wol & E1000_WUFC_BC) 1815 wol->wolopts |= WAKE_BCAST; 1816 if (adapter->wol & E1000_WUFC_MAG) 1817 wol->wolopts |= WAKE_MAGIC; 1818 if (adapter->wol & E1000_WUFC_LNKC) 1819 wol->wolopts |= WAKE_PHY; 1820 } 1821 1822 static int e1000_set_wol(struct net_device *netdev, struct ethtool_wolinfo *wol) 1823 { 1824 struct e1000_adapter *adapter = netdev_priv(netdev); 1825 1826 if (!(adapter->flags & FLAG_HAS_WOL) || 1827 !device_can_wakeup(&adapter->pdev->dev) || 1828 (wol->wolopts & ~(WAKE_UCAST | WAKE_MCAST | WAKE_BCAST | 1829 WAKE_MAGIC | WAKE_PHY))) 1830 return -EOPNOTSUPP; 1831 1832 /* these settings will always override what we currently have */ 1833 adapter->wol = 0; 1834 1835 if (wol->wolopts & WAKE_UCAST) 1836 adapter->wol |= E1000_WUFC_EX; 1837 if (wol->wolopts & WAKE_MCAST) 1838 adapter->wol |= E1000_WUFC_MC; 1839 if (wol->wolopts & WAKE_BCAST) 1840 adapter->wol |= E1000_WUFC_BC; 1841 if (wol->wolopts & WAKE_MAGIC) 1842 adapter->wol |= E1000_WUFC_MAG; 1843 if (wol->wolopts & WAKE_PHY) 1844 adapter->wol |= E1000_WUFC_LNKC; 1845 1846 device_set_wakeup_enable(&adapter->pdev->dev, adapter->wol); 1847 1848 return 0; 1849 } 1850 1851 static int e1000_set_phys_id(struct net_device *netdev, 1852 enum ethtool_phys_id_state state) 1853 { 1854 struct e1000_adapter *adapter = netdev_priv(netdev); 1855 struct e1000_hw *hw = &adapter->hw; 1856 1857 switch (state) { 1858 case ETHTOOL_ID_ACTIVE: 1859 if (!hw->mac.ops.blink_led) 1860 return 2; /* cycle on/off twice per second */ 1861 1862 hw->mac.ops.blink_led(hw); 1863 break; 1864 1865 case ETHTOOL_ID_INACTIVE: 1866 if (hw->phy.type == e1000_phy_ife) 1867 e1e_wphy(hw, IFE_PHY_SPECIAL_CONTROL_LED, 0); 1868 hw->mac.ops.led_off(hw); 1869 hw->mac.ops.cleanup_led(hw); 1870 break; 1871 1872 case ETHTOOL_ID_ON: 1873 hw->mac.ops.led_on(hw); 1874 break; 1875 1876 case ETHTOOL_ID_OFF: 1877 hw->mac.ops.led_off(hw); 1878 break; 1879 } 1880 return 0; 1881 } 1882 1883 static int e1000_get_coalesce(struct net_device *netdev, 1884 struct ethtool_coalesce *ec) 1885 { 1886 struct e1000_adapter *adapter = netdev_priv(netdev); 1887 1888 if (adapter->itr_setting <= 4) 1889 ec->rx_coalesce_usecs = adapter->itr_setting; 1890 else 1891 ec->rx_coalesce_usecs = 1000000 / adapter->itr_setting; 1892 1893 return 0; 1894 } 1895 1896 static int e1000_set_coalesce(struct net_device *netdev, 1897 struct ethtool_coalesce *ec) 1898 { 1899 struct e1000_adapter *adapter = netdev_priv(netdev); 1900 struct e1000_hw *hw = &adapter->hw; 1901 1902 if ((ec->rx_coalesce_usecs > E1000_MAX_ITR_USECS) || 1903 ((ec->rx_coalesce_usecs > 4) && 1904 (ec->rx_coalesce_usecs < E1000_MIN_ITR_USECS)) || 1905 (ec->rx_coalesce_usecs == 2)) 1906 return -EINVAL; 1907 1908 if (ec->rx_coalesce_usecs == 4) { 1909 adapter->itr = adapter->itr_setting = 4; 1910 } else if (ec->rx_coalesce_usecs <= 3) { 1911 adapter->itr = 20000; 1912 adapter->itr_setting = ec->rx_coalesce_usecs; 1913 } else { 1914 adapter->itr = (1000000 / ec->rx_coalesce_usecs); 1915 adapter->itr_setting = adapter->itr & ~3; 1916 } 1917 1918 if (adapter->itr_setting != 0) 1919 ew32(ITR, 1000000000 / (adapter->itr * 256)); 1920 else 1921 ew32(ITR, 0); 1922 1923 return 0; 1924 } 1925 1926 static int e1000_nway_reset(struct net_device *netdev) 1927 { 1928 struct e1000_adapter *adapter = netdev_priv(netdev); 1929 1930 if (!netif_running(netdev)) 1931 return -EAGAIN; 1932 1933 if (!adapter->hw.mac.autoneg) 1934 return -EINVAL; 1935 1936 e1000e_reinit_locked(adapter); 1937 1938 return 0; 1939 } 1940 1941 static void e1000_get_ethtool_stats(struct net_device *netdev, 1942 struct ethtool_stats *stats, 1943 u64 *data) 1944 { 1945 struct e1000_adapter *adapter = netdev_priv(netdev); 1946 struct rtnl_link_stats64 net_stats; 1947 int i; 1948 char *p = NULL; 1949 1950 e1000e_get_stats64(netdev, &net_stats); 1951 for (i = 0; i < E1000_GLOBAL_STATS_LEN; i++) { 1952 switch (e1000_gstrings_stats[i].type) { 1953 case NETDEV_STATS: 1954 p = (char *) &net_stats + 1955 e1000_gstrings_stats[i].stat_offset; 1956 break; 1957 case E1000_STATS: 1958 p = (char *) adapter + 1959 e1000_gstrings_stats[i].stat_offset; 1960 break; 1961 default: 1962 data[i] = 0; 1963 continue; 1964 } 1965 1966 data[i] = (e1000_gstrings_stats[i].sizeof_stat == 1967 sizeof(u64)) ? *(u64 *)p : *(u32 *)p; 1968 } 1969 } 1970 1971 static void e1000_get_strings(struct net_device *netdev, u32 stringset, 1972 u8 *data) 1973 { 1974 u8 *p = data; 1975 int i; 1976 1977 switch (stringset) { 1978 case ETH_SS_TEST: 1979 memcpy(data, e1000_gstrings_test, sizeof(e1000_gstrings_test)); 1980 break; 1981 case ETH_SS_STATS: 1982 for (i = 0; i < E1000_GLOBAL_STATS_LEN; i++) { 1983 memcpy(p, e1000_gstrings_stats[i].stat_string, 1984 ETH_GSTRING_LEN); 1985 p += ETH_GSTRING_LEN; 1986 } 1987 break; 1988 } 1989 } 1990 1991 static int e1000_get_rxnfc(struct net_device *netdev, 1992 struct ethtool_rxnfc *info, u32 *rule_locs) 1993 { 1994 info->data = 0; 1995 1996 switch (info->cmd) { 1997 case ETHTOOL_GRXFH: { 1998 struct e1000_adapter *adapter = netdev_priv(netdev); 1999 struct e1000_hw *hw = &adapter->hw; 2000 u32 mrqc = er32(MRQC); 2001 2002 if (!(mrqc & E1000_MRQC_RSS_FIELD_MASK)) 2003 return 0; 2004 2005 switch (info->flow_type) { 2006 case TCP_V4_FLOW: 2007 if (mrqc & E1000_MRQC_RSS_FIELD_IPV4_TCP) 2008 info->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3; 2009 /* fall through */ 2010 case UDP_V4_FLOW: 2011 case SCTP_V4_FLOW: 2012 case AH_ESP_V4_FLOW: 2013 case IPV4_FLOW: 2014 if (mrqc & E1000_MRQC_RSS_FIELD_IPV4) 2015 info->data |= RXH_IP_SRC | RXH_IP_DST; 2016 break; 2017 case TCP_V6_FLOW: 2018 if (mrqc & E1000_MRQC_RSS_FIELD_IPV6_TCP) 2019 info->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3; 2020 /* fall through */ 2021 case UDP_V6_FLOW: 2022 case SCTP_V6_FLOW: 2023 case AH_ESP_V6_FLOW: 2024 case IPV6_FLOW: 2025 if (mrqc & E1000_MRQC_RSS_FIELD_IPV6) 2026 info->data |= RXH_IP_SRC | RXH_IP_DST; 2027 break; 2028 default: 2029 break; 2030 } 2031 return 0; 2032 } 2033 default: 2034 return -EOPNOTSUPP; 2035 } 2036 } 2037 2038 static const struct ethtool_ops e1000_ethtool_ops = { 2039 .get_settings = e1000_get_settings, 2040 .set_settings = e1000_set_settings, 2041 .get_drvinfo = e1000_get_drvinfo, 2042 .get_regs_len = e1000_get_regs_len, 2043 .get_regs = e1000_get_regs, 2044 .get_wol = e1000_get_wol, 2045 .set_wol = e1000_set_wol, 2046 .get_msglevel = e1000_get_msglevel, 2047 .set_msglevel = e1000_set_msglevel, 2048 .nway_reset = e1000_nway_reset, 2049 .get_link = ethtool_op_get_link, 2050 .get_eeprom_len = e1000_get_eeprom_len, 2051 .get_eeprom = e1000_get_eeprom, 2052 .set_eeprom = e1000_set_eeprom, 2053 .get_ringparam = e1000_get_ringparam, 2054 .set_ringparam = e1000_set_ringparam, 2055 .get_pauseparam = e1000_get_pauseparam, 2056 .set_pauseparam = e1000_set_pauseparam, 2057 .self_test = e1000_diag_test, 2058 .get_strings = e1000_get_strings, 2059 .set_phys_id = e1000_set_phys_id, 2060 .get_ethtool_stats = e1000_get_ethtool_stats, 2061 .get_sset_count = e1000e_get_sset_count, 2062 .get_coalesce = e1000_get_coalesce, 2063 .set_coalesce = e1000_set_coalesce, 2064 .get_rxnfc = e1000_get_rxnfc, 2065 }; 2066 2067 void e1000e_set_ethtool_ops(struct net_device *netdev) 2068 { 2069 SET_ETHTOOL_OPS(netdev, &e1000_ethtool_ops); 2070 } 2071