drivers/net/ethernet/intel/e1000/e1000_ethtool.c

   1 /*******************************************************************************
   2  * Intel PRO/1000 Linux driver
   3  * Copyright(c) 1999 - 2006 Intel Corporation.
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms and conditions of the GNU General Public License,
   7  * version 2, as published by the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  12  * more details.
  13  *
  14  * The full GNU General Public License is included in this distribution in
  15  * the file called "COPYING".
  16  *
  17  * Contact Information:
  18  * Linux NICS <linux.nics@intel.com>
  19  * e1000-devel Mailing List <e1000-devel@lists.sourceforge.net>
  20  * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
  21  *
  22  ******************************************************************************/
  23
  24 /* ethtool support for e1000 */
  25
  26 #include "e1000.h"
  27 #include <linux/jiffies.h>
  28 #include <linux/uaccess.h>
  29
  30 enum {NETDEV_STATS, E1000_STATS};
  31
  32 struct e1000_stats {
  33         char stat_string[ETH_GSTRING_LEN];
  34         int type;
  35         int sizeof_stat;
  36         int stat_offset;
  37 };
  38
  39 #define E1000_STAT(m)           E1000_STATS, \
  40                                 sizeof(((struct e1000_adapter *)0)->m), \
  41                                 offsetof(struct e1000_adapter, m)
  42 #define E1000_NETDEV_STAT(m)    NETDEV_STATS, \
  43                                 sizeof(((struct net_device *)0)->m), \
  44                                 offsetof(struct net_device, m)
  45
  46 static const struct e1000_stats e1000_gstrings_stats[] = {
  47         { "rx_packets", E1000_STAT(stats.gprc) },
  48         { "tx_packets", E1000_STAT(stats.gptc) },
  49         { "rx_bytes", E1000_STAT(stats.gorcl) },
  50         { "tx_bytes", E1000_STAT(stats.gotcl) },
  51         { "rx_broadcast", E1000_STAT(stats.bprc) },
  52         { "tx_broadcast", E1000_STAT(stats.bptc) },
  53         { "rx_multicast", E1000_STAT(stats.mprc) },
  54         { "tx_multicast", E1000_STAT(stats.mptc) },
  55         { "rx_errors", E1000_STAT(stats.rxerrc) },
  56         { "tx_errors", E1000_STAT(stats.txerrc) },
  57         { "tx_dropped", E1000_NETDEV_STAT(stats.tx_dropped) },
  58         { "multicast", E1000_STAT(stats.mprc) },
  59         { "collisions", E1000_STAT(stats.colc) },
  60         { "rx_length_errors", E1000_STAT(stats.rlerrc) },
  61         { "rx_over_errors", E1000_NETDEV_STAT(stats.rx_over_errors) },
  62         { "rx_crc_errors", E1000_STAT(stats.crcerrs) },
  63         { "rx_frame_errors", E1000_NETDEV_STAT(stats.rx_frame_errors) },
  64         { "rx_no_buffer_count", E1000_STAT(stats.rnbc) },
  65         { "rx_missed_errors", E1000_STAT(stats.mpc) },
  66         { "tx_aborted_errors", E1000_STAT(stats.ecol) },
  67         { "tx_carrier_errors", E1000_STAT(stats.tncrs) },
  68         { "tx_fifo_errors", E1000_NETDEV_STAT(stats.tx_fifo_errors) },
  69         { "tx_heartbeat_errors", E1000_NETDEV_STAT(stats.tx_heartbeat_errors) },
  70         { "tx_window_errors", E1000_STAT(stats.latecol) },
  71         { "tx_abort_late_coll", E1000_STAT(stats.latecol) },
  72         { "tx_deferred_ok", E1000_STAT(stats.dc) },
  73         { "tx_single_coll_ok", E1000_STAT(stats.scc) },
  74         { "tx_multi_coll_ok", E1000_STAT(stats.mcc) },
  75         { "tx_timeout_count", E1000_STAT(tx_timeout_count) },
  76         { "tx_restart_queue", E1000_STAT(restart_queue) },
  77         { "rx_long_length_errors", E1000_STAT(stats.roc) },
  78         { "rx_short_length_errors", E1000_STAT(stats.ruc) },
  79         { "rx_align_errors", E1000_STAT(stats.algnerrc) },
  80         { "tx_tcp_seg_good", E1000_STAT(stats.tsctc) },
  81         { "tx_tcp_seg_failed", E1000_STAT(stats.tsctfc) },
  82         { "rx_flow_control_xon", E1000_STAT(stats.xonrxc) },
  83         { "rx_flow_control_xoff", E1000_STAT(stats.xoffrxc) },
  84         { "tx_flow_control_xon", E1000_STAT(stats.xontxc) },
  85         { "tx_flow_control_xoff", E1000_STAT(stats.xofftxc) },
  86         { "rx_long_byte_count", E1000_STAT(stats.gorcl) },
  87         { "rx_csum_offload_good", E1000_STAT(hw_csum_good) },
  88         { "rx_csum_offload_errors", E1000_STAT(hw_csum_err) },
  89         { "alloc_rx_buff_failed", E1000_STAT(alloc_rx_buff_failed) },
  90         { "tx_smbus", E1000_STAT(stats.mgptc) },
  91         { "rx_smbus", E1000_STAT(stats.mgprc) },
  92         { "dropped_smbus", E1000_STAT(stats.mgpdc) },
  93 };
  94
  95 #define E1000_QUEUE_STATS_LEN 0
  96 #define E1000_GLOBAL_STATS_LEN ARRAY_SIZE(e1000_gstrings_stats)
  97 #define E1000_STATS_LEN (E1000_GLOBAL_STATS_LEN + E1000_QUEUE_STATS_LEN)
  98 static const char e1000_gstrings_test[][ETH_GSTRING_LEN] = {
  99         "Register test  (offline)", "Eeprom test    (offline)",
 100         "Interrupt test (offline)", "Loopback test  (offline)",
 101         "Link test   (on/offline)"
 102 };
 103
 104 #define E1000_TEST_LEN  ARRAY_SIZE(e1000_gstrings_test)
 105
 106 static int e1000_get_link_ksettings(struct net_device *netdev,
 107                                     struct ethtool_link_ksettings *cmd)
 108 {
 109         struct e1000_adapter *adapter = netdev_priv(netdev);
 110         struct e1000_hw *hw = &adapter->hw;
 111         u32 supported, advertising;
 112
 113         if (hw->media_type == e1000_media_type_copper) {
 114                 supported = (SUPPORTED_10baseT_Half |
 115                              SUPPORTED_10baseT_Full |
 116                              SUPPORTED_100baseT_Half |
 117                              SUPPORTED_100baseT_Full |
 118                              SUPPORTED_1000baseT_Full|
 119                              SUPPORTED_Autoneg |
 120                              SUPPORTED_TP);
 121                 advertising = ADVERTISED_TP;
 122
 123                 if (hw->autoneg == 1) {
 124                         advertising |= ADVERTISED_Autoneg;
 125                         /* the e1000 autoneg seems to match ethtool nicely */
 126                         advertising |= hw->autoneg_advertised;
 127                 }
 128
 129                 cmd->base.port = PORT_TP;
 130                 cmd->base.phy_address = hw->phy_addr;
 131         } else {
 132                 supported   = (SUPPORTED_1000baseT_Full |
 133                                SUPPORTED_FIBRE |
 134                                SUPPORTED_Autoneg);
 135
 136                 advertising = (ADVERTISED_1000baseT_Full |
 137                                ADVERTISED_FIBRE |
 138                                ADVERTISED_Autoneg);
 139
 140                 cmd->base.port = PORT_FIBRE;
 141         }
 142
 143         if (er32(STATUS) & E1000_STATUS_LU) {
 144                 e1000_get_speed_and_duplex(hw, &adapter->link_speed,
 145                                            &adapter->link_duplex);
 146                 cmd->base.speed = adapter->link_speed;
 147
 148                 /* unfortunately FULL_DUPLEX != DUPLEX_FULL
 149                  * and HALF_DUPLEX != DUPLEX_HALF
 150                  */
 151                 if (adapter->link_duplex == FULL_DUPLEX)
 152                         cmd->base.duplex = DUPLEX_FULL;
 153                 else
 154                         cmd->base.duplex = DUPLEX_HALF;
 155         } else {
 156                 cmd->base.speed = SPEED_UNKNOWN;
 157                 cmd->base.duplex = DUPLEX_UNKNOWN;
 158         }
 159
 160         cmd->base.autoneg = ((hw->media_type == e1000_media_type_fiber) ||
 161                          hw->autoneg) ? AUTONEG_ENABLE : AUTONEG_DISABLE;
 162
 163         /* MDI-X => 1; MDI => 0 */
 164         if ((hw->media_type == e1000_media_type_copper) &&
 165             netif_carrier_ok(netdev))
 166                 cmd->base.eth_tp_mdix = (!!adapter->phy_info.mdix_mode ?
 167                                      ETH_TP_MDI_X : ETH_TP_MDI);
 168         else
 169                 cmd->base.eth_tp_mdix = ETH_TP_MDI_INVALID;
 170
 171         if (hw->mdix == AUTO_ALL_MODES)
 172                 cmd->base.eth_tp_mdix_ctrl = ETH_TP_MDI_AUTO;
 173         else
 174                 cmd->base.eth_tp_mdix_ctrl = hw->mdix;
 175
 176         ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.supported,
 177                                                 supported);
 178         ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.advertising,
 179                                                 advertising);
 180
 181         return 0;
 182 }
 183
 184 static int e1000_set_link_ksettings(struct net_device *netdev,
 185                                     const struct ethtool_link_ksettings *cmd)
 186 {
 187         struct e1000_adapter *adapter = netdev_priv(netdev);
 188         struct e1000_hw *hw = &adapter->hw;
 189         u32 advertising;
 190
 191         ethtool_convert_link_mode_to_legacy_u32(&advertising,
 192                                                 cmd->link_modes.advertising);
 193
 194         /* MDI setting is only allowed when autoneg enabled because
 195          * some hardware doesn't allow MDI setting when speed or
 196          * duplex is forced.
 197          */
 198         if (cmd->base.eth_tp_mdix_ctrl) {
 199                 if (hw->media_type != e1000_media_type_copper)
 200                         return -EOPNOTSUPP;
 201
 202                 if ((cmd->base.eth_tp_mdix_ctrl != ETH_TP_MDI_AUTO) &&
 203                     (cmd->base.autoneg != AUTONEG_ENABLE)) {
 204                         e_err(drv, "forcing MDI/MDI-X state is not supported when link speed and/or duplex are forced\n");
 205                         return -EINVAL;
 206                 }
 207         }
 208
 209         while (test_and_set_bit(__E1000_RESETTING, &adapter->flags))
 210                 msleep(1);
 211
 212         if (cmd->base.autoneg == AUTONEG_ENABLE) {
 213                 hw->autoneg = 1;
 214                 if (hw->media_type == e1000_media_type_fiber)
 215                         hw->autoneg_advertised = ADVERTISED_1000baseT_Full |
 216                                                  ADVERTISED_FIBRE |
 217                                                  ADVERTISED_Autoneg;
 218                 else
 219                         hw->autoneg_advertised = advertising |
 220                                                  ADVERTISED_TP |
 221                                                  ADVERTISED_Autoneg;
 222         } else {
 223                 u32 speed = cmd->base.speed;
 224                 /* calling this overrides forced MDI setting */
 225                 if (e1000_set_spd_dplx(adapter, speed, cmd->base.duplex)) {
 226                         clear_bit(__E1000_RESETTING, &adapter->flags);
 227                         return -EINVAL;
 228                 }
 229         }
 230
 231         /* MDI-X => 2; MDI => 1; Auto => 3 */
 232         if (cmd->base.eth_tp_mdix_ctrl) {
 233                 if (cmd->base.eth_tp_mdix_ctrl == ETH_TP_MDI_AUTO)
 234                         hw->mdix = AUTO_ALL_MODES;
 235                 else
 236                         hw->mdix = cmd->base.eth_tp_mdix_ctrl;
 237         }
 238
 239         /* reset the link */
 240
 241         if (netif_running(adapter->netdev)) {
 242                 e1000_down(adapter);
 243                 e1000_up(adapter);
 244         } else {
 245                 e1000_reset(adapter);
 246         }
 247         clear_bit(__E1000_RESETTING, &adapter->flags);
 248         return 0;
 249 }
 250
 251 static u32 e1000_get_link(struct net_device *netdev)
 252 {
 253         struct e1000_adapter *adapter = netdev_priv(netdev);
 254
 255         /* If the link is not reported up to netdev, interrupts are disabled,
 256          * and so the physical link state may have changed since we last
 257          * looked. Set get_link_status to make sure that the true link
 258          * state is interrogated, rather than pulling a cached and possibly
 259          * stale link state from the driver.
 260          */
 261         if (!netif_carrier_ok(netdev))
 262                 adapter->hw.get_link_status = 1;
 263
 264         return e1000_has_link(adapter);
 265 }
 266
 267 static void e1000_get_pauseparam(struct net_device *netdev,
 268                                  struct ethtool_pauseparam *pause)
 269 {
 270         struct e1000_adapter *adapter = netdev_priv(netdev);
 271         struct e1000_hw *hw = &adapter->hw;
 272
 273         pause->autoneg =
 274                 (adapter->fc_autoneg ? AUTONEG_ENABLE : AUTONEG_DISABLE);
 275
 276         if (hw->fc == E1000_FC_RX_PAUSE) {
 277                 pause->rx_pause = 1;
 278         } else if (hw->fc == E1000_FC_TX_PAUSE) {
 279                 pause->tx_pause = 1;
 280         } else if (hw->fc == E1000_FC_FULL) {
 281                 pause->rx_pause = 1;
 282                 pause->tx_pause = 1;
 283         }
 284 }
 285
 286 static int e1000_set_pauseparam(struct net_device *netdev,
 287                                 struct ethtool_pauseparam *pause)
 288 {
 289         struct e1000_adapter *adapter = netdev_priv(netdev);
 290         struct e1000_hw *hw = &adapter->hw;
 291         int retval = 0;
 292
 293         adapter->fc_autoneg = pause->autoneg;
 294
 295         while (test_and_set_bit(__E1000_RESETTING, &adapter->flags))
 296                 msleep(1);
 297
 298         if (pause->rx_pause && pause->tx_pause)
 299                 hw->fc = E1000_FC_FULL;
 300         else if (pause->rx_pause && !pause->tx_pause)
 301                 hw->fc = E1000_FC_RX_PAUSE;
 302         else if (!pause->rx_pause && pause->tx_pause)
 303                 hw->fc = E1000_FC_TX_PAUSE;
 304         else if (!pause->rx_pause && !pause->tx_pause)
 305                 hw->fc = E1000_FC_NONE;
 306
 307         hw->original_fc = hw->fc;
 308
 309         if (adapter->fc_autoneg == AUTONEG_ENABLE) {
 310                 if (netif_running(adapter->netdev)) {
 311                         e1000_down(adapter);
 312                         e1000_up(adapter);
 313                 } else {
 314                         e1000_reset(adapter);
 315                 }
 316         } else
 317                 retval = ((hw->media_type == e1000_media_type_fiber) ?
 318                           e1000_setup_link(hw) : e1000_force_mac_fc(hw));
 319
 320         clear_bit(__E1000_RESETTING, &adapter->flags);
 321         return retval;
 322 }
 323
 324 static u32 e1000_get_msglevel(struct net_device *netdev)
 325 {
 326         struct e1000_adapter *adapter = netdev_priv(netdev);
 327
 328         return adapter->msg_enable;
 329 }
 330
 331 static void e1000_set_msglevel(struct net_device *netdev, u32 data)
 332 {
 333         struct e1000_adapter *adapter = netdev_priv(netdev);
 334
 335         adapter->msg_enable = data;
 336 }
 337
 338 static int e1000_get_regs_len(struct net_device *netdev)
 339 {
 340 #define E1000_REGS_LEN 32
 341         return E1000_REGS_LEN * sizeof(u32);
 342 }
 343
 344 static void e1000_get_regs(struct net_device *netdev, struct ethtool_regs *regs,
 345                            void *p)
 346 {
 347         struct e1000_adapter *adapter = netdev_priv(netdev);
 348         struct e1000_hw *hw = &adapter->hw;
 349         u32 *regs_buff = p;
 350         u16 phy_data;
 351
 352         memset(p, 0, E1000_REGS_LEN * sizeof(u32));
 353
 354         regs->version = (1 << 24) | (hw->revision_id << 16) | hw->device_id;
 355
 356         regs_buff[0]  = er32(CTRL);
 357         regs_buff[1]  = er32(STATUS);
 358
 359         regs_buff[2]  = er32(RCTL);
 360         regs_buff[3]  = er32(RDLEN);
 361         regs_buff[4]  = er32(RDH);
 362         regs_buff[5]  = er32(RDT);
 363         regs_buff[6]  = er32(RDTR);
 364
 365         regs_buff[7]  = er32(TCTL);
 366         regs_buff[8]  = er32(TDLEN);
 367         regs_buff[9]  = er32(TDH);
 368         regs_buff[10] = er32(TDT);
 369         regs_buff[11] = er32(TIDV);
 370
 371         regs_buff[12] = hw->phy_type;  /* PHY type (IGP=1, M88=0) */
 372         if (hw->phy_type == e1000_phy_igp) {
 373                 e1000_write_phy_reg(hw, IGP01E1000_PHY_PAGE_SELECT,
 374                                     IGP01E1000_PHY_AGC_A);
 375                 e1000_read_phy_reg(hw, IGP01E1000_PHY_AGC_A &
 376                                    IGP01E1000_PHY_PAGE_SELECT, &phy_data);
 377                 regs_buff[13] = (u32)phy_data; /* cable length */
 378                 e1000_write_phy_reg(hw, IGP01E1000_PHY_PAGE_SELECT,
 379                                     IGP01E1000_PHY_AGC_B);
 380                 e1000_read_phy_reg(hw, IGP01E1000_PHY_AGC_B &
 381                                    IGP01E1000_PHY_PAGE_SELECT, &phy_data);
 382                 regs_buff[14] = (u32)phy_data; /* cable length */
 383                 e1000_write_phy_reg(hw, IGP01E1000_PHY_PAGE_SELECT,
 384                                     IGP01E1000_PHY_AGC_C);
 385                 e1000_read_phy_reg(hw, IGP01E1000_PHY_AGC_C &
 386                                    IGP01E1000_PHY_PAGE_SELECT, &phy_data);
 387                 regs_buff[15] = (u32)phy_data; /* cable length */
 388                 e1000_write_phy_reg(hw, IGP01E1000_PHY_PAGE_SELECT,
 389                                     IGP01E1000_PHY_AGC_D);
 390                 e1000_read_phy_reg(hw, IGP01E1000_PHY_AGC_D &
 391                                    IGP01E1000_PHY_PAGE_SELECT, &phy_data);
 392                 regs_buff[16] = (u32)phy_data; /* cable length */
 393                 regs_buff[17] = 0; /* extended 10bt distance (not needed) */
 394                 e1000_write_phy_reg(hw, IGP01E1000_PHY_PAGE_SELECT, 0x0);
 395                 e1000_read_phy_reg(hw, IGP01E1000_PHY_PORT_STATUS &
 396                                    IGP01E1000_PHY_PAGE_SELECT, &phy_data);
 397                 regs_buff[18] = (u32)phy_data; /* cable polarity */
 398                 e1000_write_phy_reg(hw, IGP01E1000_PHY_PAGE_SELECT,
 399                                     IGP01E1000_PHY_PCS_INIT_REG);
 400                 e1000_read_phy_reg(hw, IGP01E1000_PHY_PCS_INIT_REG &
 401                                    IGP01E1000_PHY_PAGE_SELECT, &phy_data);
 402                 regs_buff[19] = (u32)phy_data; /* cable polarity */
 403                 regs_buff[20] = 0; /* polarity correction enabled (always) */
 404                 regs_buff[22] = 0; /* phy receive errors (unavailable) */
 405                 regs_buff[23] = regs_buff[18]; /* mdix mode */
 406                 e1000_write_phy_reg(hw, IGP01E1000_PHY_PAGE_SELECT, 0x0);
 407         } else {
 408                 e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_STATUS, &phy_data);
 409                 regs_buff[13] = (u32)phy_data; /* cable length */
 410                 regs_buff[14] = 0;  /* Dummy (to align w/ IGP phy reg dump) */
 411                 regs_buff[15] = 0;  /* Dummy (to align w/ IGP phy reg dump) */
 412                 regs_buff[16] = 0;  /* Dummy (to align w/ IGP phy reg dump) */
 413                 e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, &phy_data);
 414                 regs_buff[17] = (u32)phy_data; /* extended 10bt distance */
 415                 regs_buff[18] = regs_buff[13]; /* cable polarity */
 416                 regs_buff[19] = 0;  /* Dummy (to align w/ IGP phy reg dump) */
 417                 regs_buff[20] = regs_buff[17]; /* polarity correction */
 418                 /* phy receive errors */
 419                 regs_buff[22] = adapter->phy_stats.receive_errors;
 420                 regs_buff[23] = regs_buff[13]; /* mdix mode */
 421         }
 422         regs_buff[21] = adapter->phy_stats.idle_errors;  /* phy idle errors */
 423         e1000_read_phy_reg(hw, PHY_1000T_STATUS, &phy_data);
 424         regs_buff[24] = (u32)phy_data;  /* phy local receiver status */
 425         regs_buff[25] = regs_buff[24];  /* phy remote receiver status */
 426         if (hw->mac_type >= e1000_82540 &&
 427             hw->media_type == e1000_media_type_copper) {
 428                 regs_buff[26] = er32(MANC);
 429         }
 430 }
 431
 432 static int e1000_get_eeprom_len(struct net_device *netdev)
 433 {
 434         struct e1000_adapter *adapter = netdev_priv(netdev);
 435         struct e1000_hw *hw = &adapter->hw;
 436
 437         return hw->eeprom.word_size * 2;
 438 }
 439
 440 static int e1000_get_eeprom(struct net_device *netdev,
 441                             struct ethtool_eeprom *eeprom, u8 *bytes)
 442 {
 443         struct e1000_adapter *adapter = netdev_priv(netdev);
 444         struct e1000_hw *hw = &adapter->hw;
 445         u16 *eeprom_buff;
 446         int first_word, last_word;
 447         int ret_val = 0;
 448         u16 i;
 449
 450         if (eeprom->len == 0)
 451                 return -EINVAL;
 452
 453         eeprom->magic = hw->vendor_id | (hw->device_id << 16);
 454
 455         first_word = eeprom->offset >> 1;
 456         last_word = (eeprom->offset + eeprom->len - 1) >> 1;
 457
 458         eeprom_buff = kmalloc(sizeof(u16) *
 459                         (last_word - first_word + 1), GFP_KERNEL);
 460         if (!eeprom_buff)
 461                 return -ENOMEM;
 462
 463         if (hw->eeprom.type == e1000_eeprom_spi)
 464                 ret_val = e1000_read_eeprom(hw, first_word,
 465                                             last_word - first_word + 1,
 466                                             eeprom_buff);
 467         else {
 468                 for (i = 0; i < last_word - first_word + 1; i++) {
 469                         ret_val = e1000_read_eeprom(hw, first_word + i, 1,
 470                                                     &eeprom_buff[i]);
 471                         if (ret_val)
 472                                 break;
 473                 }
 474         }
 475
 476         /* Device's eeprom is always little-endian, word addressable */
 477         for (i = 0; i < last_word - first_word + 1; i++)
 478                 le16_to_cpus(&eeprom_buff[i]);
 479
 480         memcpy(bytes, (u8 *)eeprom_buff + (eeprom->offset & 1),
 481                eeprom->len);
 482         kfree(eeprom_buff);
 483
 484         return ret_val;
 485 }
 486
 487 static int e1000_set_eeprom(struct net_device *netdev,
 488                             struct ethtool_eeprom *eeprom, u8 *bytes)
 489 {
 490         struct e1000_adapter *adapter = netdev_priv(netdev);
 491         struct e1000_hw *hw = &adapter->hw;
 492         u16 *eeprom_buff;
 493         void *ptr;
 494         int max_len, first_word, last_word, ret_val = 0;
 495         u16 i;
 496
 497         if (eeprom->len == 0)
 498                 return -EOPNOTSUPP;
 499
 500         if (eeprom->magic != (hw->vendor_id | (hw->device_id << 16)))
 501                 return -EFAULT;
 502
 503         max_len = hw->eeprom.word_size * 2;
 504
 505         first_word = eeprom->offset >> 1;
 506         last_word = (eeprom->offset + eeprom->len - 1) >> 1;
 507         eeprom_buff = kmalloc(max_len, GFP_KERNEL);
 508         if (!eeprom_buff)
 509                 return -ENOMEM;
 510
 511         ptr = (void *)eeprom_buff;
 512
 513         if (eeprom->offset & 1) {
 514                 /* need read/modify/write of first changed EEPROM word
 515                  * only the second byte of the word is being modified
 516                  */
 517                 ret_val = e1000_read_eeprom(hw, first_word, 1,
 518                                             &eeprom_buff[0]);
 519                 ptr++;
 520         }
 521         if (((eeprom->offset + eeprom->len) & 1) && (ret_val == 0)) {
 522                 /* need read/modify/write of last changed EEPROM word
 523                  * only the first byte of the word is being modified
 524                  */
 525                 ret_val = e1000_read_eeprom(hw, last_word, 1,
 526                                             &eeprom_buff[last_word - first_word]);
 527         }
 528
 529         /* Device's eeprom is always little-endian, word addressable */
 530         for (i = 0; i < last_word - first_word + 1; i++)
 531                 le16_to_cpus(&eeprom_buff[i]);
 532
 533         memcpy(ptr, bytes, eeprom->len);
 534
 535         for (i = 0; i < last_word - first_word + 1; i++)
 536                 eeprom_buff[i] = cpu_to_le16(eeprom_buff[i]);
 537
 538         ret_val = e1000_write_eeprom(hw, first_word,
 539                                      last_word - first_word + 1, eeprom_buff);
 540
 541         /* Update the checksum over the first part of the EEPROM if needed */
 542         if ((ret_val == 0) && (first_word <= EEPROM_CHECKSUM_REG))
 543                 e1000_update_eeprom_checksum(hw);
 544
 545         kfree(eeprom_buff);
 546         return ret_val;
 547 }
 548
 549 static void e1000_get_drvinfo(struct net_device *netdev,
 550                               struct ethtool_drvinfo *drvinfo)
 551 {
 552         struct e1000_adapter *adapter = netdev_priv(netdev);
 553
 554         strlcpy(drvinfo->driver,  e1000_driver_name,
 555                 sizeof(drvinfo->driver));
 556         strlcpy(drvinfo->version, e1000_driver_version,
 557                 sizeof(drvinfo->version));
 558
 559         strlcpy(drvinfo->bus_info, pci_name(adapter->pdev),
 560                 sizeof(drvinfo->bus_info));
 561 }
 562
 563 static void e1000_get_ringparam(struct net_device *netdev,
 564                                 struct ethtool_ringparam *ring)
 565 {
 566         struct e1000_adapter *adapter = netdev_priv(netdev);
 567         struct e1000_hw *hw = &adapter->hw;
 568         e1000_mac_type mac_type = hw->mac_type;
 569         struct e1000_tx_ring *txdr = adapter->tx_ring;
 570         struct e1000_rx_ring *rxdr = adapter->rx_ring;
 571
 572         ring->rx_max_pending = (mac_type < e1000_82544) ? E1000_MAX_RXD :
 573                 E1000_MAX_82544_RXD;
 574         ring->tx_max_pending = (mac_type < e1000_82544) ? E1000_MAX_TXD :
 575                 E1000_MAX_82544_TXD;
 576         ring->rx_pending = rxdr->count;
 577         ring->tx_pending = txdr->count;
 578 }
 579
 580 static int e1000_set_ringparam(struct net_device *netdev,
 581                                struct ethtool_ringparam *ring)
 582 {
 583         struct e1000_adapter *adapter = netdev_priv(netdev);
 584         struct e1000_hw *hw = &adapter->hw;
 585         e1000_mac_type mac_type = hw->mac_type;
 586         struct e1000_tx_ring *txdr, *tx_old;
 587         struct e1000_rx_ring *rxdr, *rx_old;
 588         int i, err;
 589
 590         if ((ring->rx_mini_pending) || (ring->rx_jumbo_pending))
 591                 return -EINVAL;
 592
 593         while (test_and_set_bit(__E1000_RESETTING, &adapter->flags))
 594                 msleep(1);
 595
 596         if (netif_running(adapter->netdev))
 597                 e1000_down(adapter);
 598
 599         tx_old = adapter->tx_ring;
 600         rx_old = adapter->rx_ring;
 601
 602         err = -ENOMEM;
 603         txdr = kcalloc(adapter->num_tx_queues, sizeof(struct e1000_tx_ring),
 604                        GFP_KERNEL);
 605         if (!txdr)
 606                 goto err_alloc_tx;
 607
 608         rxdr = kcalloc(adapter->num_rx_queues, sizeof(struct e1000_rx_ring),
 609                        GFP_KERNEL);
 610         if (!rxdr)
 611                 goto err_alloc_rx;
 612
 613         adapter->tx_ring = txdr;
 614         adapter->rx_ring = rxdr;
 615
 616         rxdr->count = max(ring->rx_pending, (u32)E1000_MIN_RXD);
 617         rxdr->count = min(rxdr->count, (u32)(mac_type < e1000_82544 ?
 618                           E1000_MAX_RXD : E1000_MAX_82544_RXD));
 619         rxdr->count = ALIGN(rxdr->count, REQ_RX_DESCRIPTOR_MULTIPLE);
 620         txdr->count = max(ring->tx_pending, (u32)E1000_MIN_TXD);
 621         txdr->count = min(txdr->count, (u32)(mac_type < e1000_82544 ?
 622                           E1000_MAX_TXD : E1000_MAX_82544_TXD));
 623         txdr->count = ALIGN(txdr->count, REQ_TX_DESCRIPTOR_MULTIPLE);
 624
 625         for (i = 0; i < adapter->num_tx_queues; i++)
 626                 txdr[i].count = txdr->count;
 627         for (i = 0; i < adapter->num_rx_queues; i++)
 628                 rxdr[i].count = rxdr->count;
 629
 630         if (netif_running(adapter->netdev)) {
 631                 /* Try to get new resources before deleting old */
 632                 err = e1000_setup_all_rx_resources(adapter);
 633                 if (err)
 634                         goto err_setup_rx;
 635                 err = e1000_setup_all_tx_resources(adapter);
 636                 if (err)
 637                         goto err_setup_tx;
 638
 639                 /* save the new, restore the old in order to free it,
 640                  * then restore the new back again
 641                  */
 642
 643                 adapter->rx_ring = rx_old;
 644                 adapter->tx_ring = tx_old;
 645                 e1000_free_all_rx_resources(adapter);
 646                 e1000_free_all_tx_resources(adapter);
 647                 kfree(tx_old);
 648                 kfree(rx_old);
 649                 adapter->rx_ring = rxdr;
 650                 adapter->tx_ring = txdr;
 651                 err = e1000_up(adapter);
 652                 if (err)
 653                         goto err_setup;
 654         }
 655
 656         clear_bit(__E1000_RESETTING, &adapter->flags);
 657         return 0;
 658 err_setup_tx:
 659         e1000_free_all_rx_resources(adapter);
 660 err_setup_rx:
 661         adapter->rx_ring = rx_old;
 662         adapter->tx_ring = tx_old;
 663         kfree(rxdr);
 664 err_alloc_rx:
 665         kfree(txdr);
 666 err_alloc_tx:
 667         e1000_up(adapter);
 668 err_setup:
 669         clear_bit(__E1000_RESETTING, &adapter->flags);
 670         return err;
 671 }
 672
 673 static bool reg_pattern_test(struct e1000_adapter *adapter, u64 *data, int reg,
 674                              u32 mask, u32 write)
 675 {
 676         struct e1000_hw *hw = &adapter->hw;
 677         static const u32 test[] = {
 678                 0x5A5A5A5A, 0xA5A5A5A5, 0x00000000, 0xFFFFFFFF
 679         };
 680         u8 __iomem *address = hw->hw_addr + reg;
 681         u32 read;
 682         int i;
 683
 684         for (i = 0; i < ARRAY_SIZE(test); i++) {
 685                 writel(write & test[i], address);
 686                 read = readl(address);
 687                 if (read != (write & test[i] & mask)) {
 688                         e_err(drv, "pattern test reg %04X failed: "
 689                               "got 0x%08X expected 0x%08X\n",
 690                               reg, read, (write & test[i] & mask));
 691                         *data = reg;
 692                         return true;
 693                 }
 694         }
 695         return false;
 696 }
 697
 698 static bool reg_set_and_check(struct e1000_adapter *adapter, u64 *data, int reg,
 699                               u32 mask, u32 write)
 700 {
 701         struct e1000_hw *hw = &adapter->hw;
 702         u8 __iomem *address = hw->hw_addr + reg;
 703         u32 read;
 704
 705         writel(write & mask, address);
 706         read = readl(address);
 707         if ((read & mask) != (write & mask)) {
 708                 e_err(drv, "set/check reg %04X test failed: "
 709                       "got 0x%08X expected 0x%08X\n",
 710                       reg, (read & mask), (write & mask));
 711                 *data = reg;
 712                 return true;
 713         }
 714         return false;
 715 }
 716
 717 #define REG_PATTERN_TEST(reg, mask, write)                           \
 718         do {                                                         \
 719                 if (reg_pattern_test(adapter, data,                  \
 720                              (hw->mac_type >= e1000_82543)   \
 721                              ? E1000_##reg : E1000_82542_##reg,      \
 722                              mask, write))                           \
 723                         return 1;                                    \
 724         } while (0)
 725
 726 #define REG_SET_AND_CHECK(reg, mask, write)                          \
 727         do {                                                         \
 728                 if (reg_set_and_check(adapter, data,                 \
 729                               (hw->mac_type >= e1000_82543)  \
 730                               ? E1000_##reg : E1000_82542_##reg,     \
 731                               mask, write))                          \
 732                         return 1;                                    \
 733         } while (0)
 734
 735 static int e1000_reg_test(struct e1000_adapter *adapter, u64 *data)
 736 {
 737         u32 value, before, after;
 738         u32 i, toggle;
 739         struct e1000_hw *hw = &adapter->hw;
 740
 741         /* The status register is Read Only, so a write should fail.
 742          * Some bits that get toggled are ignored.
 743          */
 744
 745         /* there are several bits on newer hardware that are r/w */
 746         toggle = 0xFFFFF833;
 747
 748         before = er32(STATUS);
 749         value = (er32(STATUS) & toggle);
 750         ew32(STATUS, toggle);
 751         after = er32(STATUS) & toggle;
 752         if (value != after) {
 753                 e_err(drv, "failed STATUS register test got: "
 754                       "0x%08X expected: 0x%08X\n", after, value);
 755                 *data = 1;
 756                 return 1;
 757         }
 758         /* restore previous status */
 759         ew32(STATUS, before);
 760
 761         REG_PATTERN_TEST(FCAL, 0xFFFFFFFF, 0xFFFFFFFF);
 762         REG_PATTERN_TEST(FCAH, 0x0000FFFF, 0xFFFFFFFF);
 763         REG_PATTERN_TEST(FCT, 0x0000FFFF, 0xFFFFFFFF);
 764         REG_PATTERN_TEST(VET, 0x0000FFFF, 0xFFFFFFFF);
 765
 766         REG_PATTERN_TEST(RDTR, 0x0000FFFF, 0xFFFFFFFF);
 767         REG_PATTERN_TEST(RDBAH, 0xFFFFFFFF, 0xFFFFFFFF);
 768         REG_PATTERN_TEST(RDLEN, 0x000FFF80, 0x000FFFFF);
 769         REG_PATTERN_TEST(RDH, 0x0000FFFF, 0x0000FFFF);
 770         REG_PATTERN_TEST(RDT, 0x0000FFFF, 0x0000FFFF);
 771         REG_PATTERN_TEST(FCRTH, 0x0000FFF8, 0x0000FFF8);
 772         REG_PATTERN_TEST(FCTTV, 0x0000FFFF, 0x0000FFFF);
 773         REG_PATTERN_TEST(TIPG, 0x3FFFFFFF, 0x3FFFFFFF);
 774         REG_PATTERN_TEST(TDBAH, 0xFFFFFFFF, 0xFFFFFFFF);
 775         REG_PATTERN_TEST(TDLEN, 0x000FFF80, 0x000FFFFF);
 776
 777         REG_SET_AND_CHECK(RCTL, 0xFFFFFFFF, 0x00000000);
 778
 779         before = 0x06DFB3FE;
 780         REG_SET_AND_CHECK(RCTL, before, 0x003FFFFB);
 781         REG_SET_AND_CHECK(TCTL, 0xFFFFFFFF, 0x00000000);
 782
 783         if (hw->mac_type >= e1000_82543) {
 784                 REG_SET_AND_CHECK(RCTL, before, 0xFFFFFFFF);
 785                 REG_PATTERN_TEST(RDBAL, 0xFFFFFFF0, 0xFFFFFFFF);
 786                 REG_PATTERN_TEST(TXCW, 0xC000FFFF, 0x0000FFFF);
 787                 REG_PATTERN_TEST(TDBAL, 0xFFFFFFF0, 0xFFFFFFFF);
 788                 REG_PATTERN_TEST(TIDV, 0x0000FFFF, 0x0000FFFF);
 789                 value = E1000_RAR_ENTRIES;
 790                 for (i = 0; i < value; i++) {
 791                         REG_PATTERN_TEST(RA + (((i << 1) + 1) << 2),
 792                                          0x8003FFFF, 0xFFFFFFFF);
 793                 }
 794         } else {
 795                 REG_SET_AND_CHECK(RCTL, 0xFFFFFFFF, 0x01FFFFFF);
 796                 REG_PATTERN_TEST(RDBAL, 0xFFFFF000, 0xFFFFFFFF);
 797                 REG_PATTERN_TEST(TXCW, 0x0000FFFF, 0x0000FFFF);
 798                 REG_PATTERN_TEST(TDBAL, 0xFFFFF000, 0xFFFFFFFF);
 799         }
 800
 801         value = E1000_MC_TBL_SIZE;
 802         for (i = 0; i < value; i++)
 803                 REG_PATTERN_TEST(MTA + (i << 2), 0xFFFFFFFF, 0xFFFFFFFF);
 804
 805         *data = 0;
 806         return 0;
 807 }
 808
 809 static int e1000_eeprom_test(struct e1000_adapter *adapter, u64 *data)
 810 {
 811         struct e1000_hw *hw = &adapter->hw;
 812         u16 temp;
 813         u16 checksum = 0;
 814         u16 i;
 815
 816         *data = 0;
 817         /* Read and add up the contents of the EEPROM */
 818         for (i = 0; i < (EEPROM_CHECKSUM_REG + 1); i++) {
 819                 if ((e1000_read_eeprom(hw, i, 1, &temp)) < 0) {
 820                         *data = 1;
 821                         break;
 822                 }
 823                 checksum += temp;
 824         }
 825
 826         /* If Checksum is not Correct return error else test passed */
 827         if ((checksum != (u16)EEPROM_SUM) && !(*data))
 828                 *data = 2;
 829
 830         return *data;
 831 }
 832
 833 static irqreturn_t e1000_test_intr(int irq, void *data)
 834 {
 835         struct net_device *netdev = (struct net_device *)data;
 836         struct e1000_adapter *adapter = netdev_priv(netdev);
 837         struct e1000_hw *hw = &adapter->hw;
 838
 839         adapter->test_icr |= er32(ICR);
 840
 841         return IRQ_HANDLED;
 842 }
 843
 844 static int e1000_intr_test(struct e1000_adapter *adapter, u64 *data)
 845 {
 846         struct net_device *netdev = adapter->netdev;
 847         u32 mask, i = 0;
 848         bool shared_int = true;
 849         u32 irq = adapter->pdev->irq;
 850         struct e1000_hw *hw = &adapter->hw;
 851
 852         *data = 0;
 853
 854         /* NOTE: we don't test MSI interrupts here, yet
 855          * Hook up test interrupt handler just for this test
 856          */
 857         if (!request_irq(irq, e1000_test_intr, IRQF_PROBE_SHARED, netdev->name,
 858                          netdev))
 859                 shared_int = false;
 860         else if (request_irq(irq, e1000_test_intr, IRQF_SHARED,
 861                              netdev->name, netdev)) {
 862                 *data = 1;
 863                 return -1;
 864         }
 865         e_info(hw, "testing %s interrupt\n", (shared_int ?
 866                "shared" : "unshared"));
 867
 868         /* Disable all the interrupts */
 869         ew32(IMC, 0xFFFFFFFF);
 870         E1000_WRITE_FLUSH();
 871         msleep(10);
 872
 873         /* Test each interrupt */
 874         for (; i < 10; i++) {
 875                 /* Interrupt to test */
 876                 mask = 1 << i;
 877
 878                 if (!shared_int) {
 879                         /* Disable the interrupt to be reported in
 880                          * the cause register and then force the same
 881                          * interrupt and see if one gets posted.  If
 882                          * an interrupt was posted to the bus, the
 883                          * test failed.
 884                          */
 885                         adapter->test_icr = 0;
 886                         ew32(IMC, mask);
 887                         ew32(ICS, mask);
 888                         E1000_WRITE_FLUSH();
 889                         msleep(10);
 890
 891                         if (adapter->test_icr & mask) {
 892                                 *data = 3;
 893                                 break;
 894                         }
 895                 }
 896
 897                 /* Enable the interrupt to be reported in
 898                  * the cause register and then force the same
 899                  * interrupt and see if one gets posted.  If
 900                  * an interrupt was not posted to the bus, the
 901                  * test failed.
 902                  */
 903                 adapter->test_icr = 0;
 904                 ew32(IMS, mask);
 905                 ew32(ICS, mask);
 906                 E1000_WRITE_FLUSH();
 907                 msleep(10);
 908
 909                 if (!(adapter->test_icr & mask)) {
 910                         *data = 4;
 911                         break;
 912                 }
 913
 914                 if (!shared_int) {
 915                         /* Disable the other interrupts to be reported in
 916                          * the cause register and then force the other
 917                          * interrupts and see if any get posted.  If
 918                          * an interrupt was posted to the bus, the
 919                          * test failed.
 920                          */
 921                         adapter->test_icr = 0;
 922                         ew32(IMC, ~mask & 0x00007FFF);
 923                         ew32(ICS, ~mask & 0x00007FFF);
 924                         E1000_WRITE_FLUSH();
 925                         msleep(10);
 926
 927                         if (adapter->test_icr) {
 928                                 *data = 5;
 929                                 break;
 930                         }
 931                 }
 932         }
 933
 934         /* Disable all the interrupts */
 935         ew32(IMC, 0xFFFFFFFF);
 936         E1000_WRITE_FLUSH();
 937         msleep(10);
 938
 939         /* Unhook test interrupt handler */
 940         free_irq(irq, netdev);
 941
 942         return *data;
 943 }
 944
 945 static void e1000_free_desc_rings(struct e1000_adapter *adapter)
 946 {
 947         struct e1000_tx_ring *txdr = &adapter->test_tx_ring;
 948         struct e1000_rx_ring *rxdr = &adapter->test_rx_ring;
 949         struct pci_dev *pdev = adapter->pdev;
 950         int i;
 951
 952         if (txdr->desc && txdr->buffer_info) {
 953                 for (i = 0; i < txdr->count; i++) {
 954                         if (txdr->buffer_info[i].dma)
 955                                 dma_unmap_single(&pdev->dev,
 956                                                  txdr->buffer_info[i].dma,
 957                                                  txdr->buffer_info[i].length,
 958                                                  DMA_TO_DEVICE);
 959                         if (txdr->buffer_info[i].skb)
 960                                 dev_kfree_skb(txdr->buffer_info[i].skb);
 961                 }
 962         }
 963
 964         if (rxdr->desc && rxdr->buffer_info) {
 965                 for (i = 0; i < rxdr->count; i++) {
 966                         if (rxdr->buffer_info[i].dma)
 967                                 dma_unmap_single(&pdev->dev,
 968                                                  rxdr->buffer_info[i].dma,
 969                                                  E1000_RXBUFFER_2048,
 970                                                  DMA_FROM_DEVICE);
 971                         kfree(rxdr->buffer_info[i].rxbuf.data);
 972                 }
 973         }
 974
 975         if (txdr->desc) {
 976                 dma_free_coherent(&pdev->dev, txdr->size, txdr->desc,
 977                                   txdr->dma);
 978                 txdr->desc = NULL;
 979         }
 980         if (rxdr->desc) {
 981                 dma_free_coherent(&pdev->dev, rxdr->size, rxdr->desc,
 982                                   rxdr->dma);
 983                 rxdr->desc = NULL;
 984         }
 985
 986         kfree(txdr->buffer_info);
 987         txdr->buffer_info = NULL;
 988         kfree(rxdr->buffer_info);
 989         rxdr->buffer_info = NULL;
 990 }
 991
 992 static int e1000_setup_desc_rings(struct e1000_adapter *adapter)
 993 {
 994         struct e1000_hw *hw = &adapter->hw;
 995         struct e1000_tx_ring *txdr = &adapter->test_tx_ring;
 996         struct e1000_rx_ring *rxdr = &adapter->test_rx_ring;
 997         struct pci_dev *pdev = adapter->pdev;
 998         u32 rctl;
 999         int i, ret_val;
1000
1001         /* Setup Tx descriptor ring and Tx buffers */
1002
1003         if (!txdr->count)
1004                 txdr->count = E1000_DEFAULT_TXD;
1005
1006         txdr->buffer_info = kcalloc(txdr->count, sizeof(struct e1000_tx_buffer),
1007                                     GFP_KERNEL);
1008         if (!txdr->buffer_info) {
1009                 ret_val = 1;
1010                 goto err_nomem;
1011         }
1012
1013         txdr->size = txdr->count * sizeof(struct e1000_tx_desc);
1014         txdr->size = ALIGN(txdr->size, 4096);
1015         txdr->desc = dma_zalloc_coherent(&pdev->dev, txdr->size, &txdr->dma,
1016                                          GFP_KERNEL);
1017         if (!txdr->desc) {
1018                 ret_val = 2;
1019                 goto err_nomem;
1020         }
1021         txdr->next_to_use = txdr->next_to_clean = 0;
1022
1023         ew32(TDBAL, ((u64)txdr->dma & 0x00000000FFFFFFFF));
1024         ew32(TDBAH, ((u64)txdr->dma >> 32));
1025         ew32(TDLEN, txdr->count * sizeof(struct e1000_tx_desc));
1026         ew32(TDH, 0);
1027         ew32(TDT, 0);
1028         ew32(TCTL, E1000_TCTL_PSP | E1000_TCTL_EN |
1029              E1000_COLLISION_THRESHOLD << E1000_CT_SHIFT |
1030              E1000_FDX_COLLISION_DISTANCE << E1000_COLD_SHIFT);
1031
1032         for (i = 0; i < txdr->count; i++) {
1033                 struct e1000_tx_desc *tx_desc = E1000_TX_DESC(*txdr, i);
1034                 struct sk_buff *skb;
1035                 unsigned int size = 1024;
1036
1037                 skb = alloc_skb(size, GFP_KERNEL);
1038                 if (!skb) {
1039                         ret_val = 3;
1040                         goto err_nomem;
1041                 }
1042                 skb_put(skb, size);
1043                 txdr->buffer_info[i].skb = skb;
1044                 txdr->buffer_info[i].length = skb->len;
1045                 txdr->buffer_info[i].dma =
1046                         dma_map_single(&pdev->dev, skb->data, skb->len,
1047                                        DMA_TO_DEVICE);
1048                 if (dma_mapping_error(&pdev->dev, txdr->buffer_info[i].dma)) {
1049                         ret_val = 4;
1050                         goto err_nomem;
1051                 }
1052                 tx_desc->buffer_addr = cpu_to_le64(txdr->buffer_info[i].dma);
1053                 tx_desc->lower.data = cpu_to_le32(skb->len);
1054                 tx_desc->lower.data |= cpu_to_le32(E1000_TXD_CMD_EOP |
1055                                                    E1000_TXD_CMD_IFCS |
1056                                                    E1000_TXD_CMD_RPS);
1057                 tx_desc->upper.data = 0;
1058         }
1059
1060         /* Setup Rx descriptor ring and Rx buffers */
1061
1062         if (!rxdr->count)
1063                 rxdr->count = E1000_DEFAULT_RXD;
1064
1065         rxdr->buffer_info = kcalloc(rxdr->count, sizeof(struct e1000_rx_buffer),
1066                                     GFP_KERNEL);
1067         if (!rxdr->buffer_info) {
1068                 ret_val = 5;
1069                 goto err_nomem;
1070         }
1071
1072         rxdr->size = rxdr->count * sizeof(struct e1000_rx_desc);
1073         rxdr->desc = dma_zalloc_coherent(&pdev->dev, rxdr->size, &rxdr->dma,
1074                                          GFP_KERNEL);
1075         if (!rxdr->desc) {
1076                 ret_val = 6;
1077                 goto err_nomem;
1078         }
1079         rxdr->next_to_use = rxdr->next_to_clean = 0;
1080
1081         rctl = er32(RCTL);
1082         ew32(RCTL, rctl & ~E1000_RCTL_EN);
1083         ew32(RDBAL, ((u64)rxdr->dma & 0xFFFFFFFF));
1084         ew32(RDBAH, ((u64)rxdr->dma >> 32));
1085         ew32(RDLEN, rxdr->size);
1086         ew32(RDH, 0);
1087         ew32(RDT, 0);
1088         rctl = E1000_RCTL_EN | E1000_RCTL_BAM | E1000_RCTL_SZ_2048 |
1089                 E1000_RCTL_LBM_NO | E1000_RCTL_RDMTS_HALF |
1090                 (hw->mc_filter_type << E1000_RCTL_MO_SHIFT);
1091         ew32(RCTL, rctl);
1092
1093         for (i = 0; i < rxdr->count; i++) {
1094                 struct e1000_rx_desc *rx_desc = E1000_RX_DESC(*rxdr, i);
1095                 u8 *buf;
1096
1097                 buf = kzalloc(E1000_RXBUFFER_2048 + NET_SKB_PAD + NET_IP_ALIGN,
1098                               GFP_KERNEL);
1099                 if (!buf) {
1100                         ret_val = 7;
1101                         goto err_nomem;
1102                 }
1103                 rxdr->buffer_info[i].rxbuf.data = buf;
1104
1105                 rxdr->buffer_info[i].dma =
1106                         dma_map_single(&pdev->dev,
1107                                        buf + NET_SKB_PAD + NET_IP_ALIGN,
1108                                        E1000_RXBUFFER_2048, DMA_FROM_DEVICE);
1109                 if (dma_mapping_error(&pdev->dev, rxdr->buffer_info[i].dma)) {
1110                         ret_val = 8;
1111                         goto err_nomem;
1112                 }
1113                 rx_desc->buffer_addr = cpu_to_le64(rxdr->buffer_info[i].dma);
1114         }
1115
1116         return 0;
1117
1118 err_nomem:
1119         e1000_free_desc_rings(adapter);
1120         return ret_val;
1121 }
1122
1123 static void e1000_phy_disable_receiver(struct e1000_adapter *adapter)
1124 {
1125         struct e1000_hw *hw = &adapter->hw;
1126
1127         /* Write out to PHY registers 29 and 30 to disable the Receiver. */
1128         e1000_write_phy_reg(hw, 29, 0x001F);
1129         e1000_write_phy_reg(hw, 30, 0x8FFC);
1130         e1000_write_phy_reg(hw, 29, 0x001A);
1131         e1000_write_phy_reg(hw, 30, 0x8FF0);
1132 }
1133
1134 static void e1000_phy_reset_clk_and_crs(struct e1000_adapter *adapter)
1135 {
1136         struct e1000_hw *hw = &adapter->hw;
1137         u16 phy_reg;
1138
1139         /* Because we reset the PHY above, we need to re-force TX_CLK in the
1140          * Extended PHY Specific Control Register to 25MHz clock.  This
1141          * value defaults back to a 2.5MHz clock when the PHY is reset.
1142          */
1143         e1000_read_phy_reg(hw, M88E1000_EXT_PHY_SPEC_CTRL, &phy_reg);
1144         phy_reg |= M88E1000_EPSCR_TX_CLK_25;
1145         e1000_write_phy_reg(hw, M88E1000_EXT_PHY_SPEC_CTRL, phy_reg);
1146
1147         /* In addition, because of the s/w reset above, we need to enable
1148          * CRS on TX.  This must be set for both full and half duplex
1149          * operation.
1150          */
1151         e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, &phy_reg);
1152         phy_reg |= M88E1000_PSCR_ASSERT_CRS_ON_TX;
1153         e1000_write_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, phy_reg);
1154 }
1155
1156 static int e1000_nonintegrated_phy_loopback(struct e1000_adapter *adapter)
1157 {
1158         struct e1000_hw *hw = &adapter->hw;
1159         u32 ctrl_reg;
1160         u16 phy_reg;
1161
1162         /* Setup the Device Control Register for PHY loopback test. */
1163
1164         ctrl_reg = er32(CTRL);
1165         ctrl_reg |= (E1000_CTRL_ILOS |          /* Invert Loss-Of-Signal */
1166                      E1000_CTRL_FRCSPD |        /* Set the Force Speed Bit */
1167                      E1000_CTRL_FRCDPX |        /* Set the Force Duplex Bit */
1168                      E1000_CTRL_SPD_1000 |      /* Force Speed to 1000 */
1169                      E1000_CTRL_FD);            /* Force Duplex to FULL */
1170
1171         ew32(CTRL, ctrl_reg);
1172
1173         /* Read the PHY Specific Control Register (0x10) */
1174         e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, &phy_reg);
1175
1176         /* Clear Auto-Crossover bits in PHY Specific Control Register
1177          * (bits 6:5).
1178          */
1179         phy_reg &= ~M88E1000_PSCR_AUTO_X_MODE;
1180         e1000_write_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, phy_reg);
1181
1182         /* Perform software reset on the PHY */
1183         e1000_phy_reset(hw);
1184
1185         /* Have to setup TX_CLK and TX_CRS after software reset */
1186         e1000_phy_reset_clk_and_crs(adapter);
1187
1188         e1000_write_phy_reg(hw, PHY_CTRL, 0x8100);
1189
1190         /* Wait for reset to complete. */
1191         udelay(500);
1192
1193         /* Have to setup TX_CLK and TX_CRS after software reset */
1194         e1000_phy_reset_clk_and_crs(adapter);
1195
1196         /* Write out to PHY registers 29 and 30 to disable the Receiver. */
1197         e1000_phy_disable_receiver(adapter);
1198
1199         /* Set the loopback bit in the PHY control register. */
1200         e1000_read_phy_reg(hw, PHY_CTRL, &phy_reg);
1201         phy_reg |= MII_CR_LOOPBACK;
1202         e1000_write_phy_reg(hw, PHY_CTRL, phy_reg);
1203
1204         /* Setup TX_CLK and TX_CRS one more time. */
1205         e1000_phy_reset_clk_and_crs(adapter);
1206
1207         /* Check Phy Configuration */
1208         e1000_read_phy_reg(hw, PHY_CTRL, &phy_reg);
1209         if (phy_reg != 0x4100)
1210                 return 9;
1211
1212         e1000_read_phy_reg(hw, M88E1000_EXT_PHY_SPEC_CTRL, &phy_reg);
1213         if (phy_reg != 0x0070)
1214                 return 10;
1215
1216         e1000_read_phy_reg(hw, 29, &phy_reg);
1217         if (phy_reg != 0x001A)
1218                 return 11;
1219
1220         return 0;
1221 }
1222
1223 static int e1000_integrated_phy_loopback(struct e1000_adapter *adapter)
1224 {
1225         struct e1000_hw *hw = &adapter->hw;
1226         u32 ctrl_reg = 0;
1227         u32 stat_reg = 0;
1228
1229         hw->autoneg = false;
1230
1231         if (hw->phy_type == e1000_phy_m88) {
1232                 /* Auto-MDI/MDIX Off */
1233                 e1000_write_phy_reg(hw,
1234                                     M88E1000_PHY_SPEC_CTRL, 0x0808);
1235                 /* reset to update Auto-MDI/MDIX */
1236                 e1000_write_phy_reg(hw, PHY_CTRL, 0x9140);
1237                 /* autoneg off */
1238                 e1000_write_phy_reg(hw, PHY_CTRL, 0x8140);
1239         }
1240
1241         ctrl_reg = er32(CTRL);
1242
1243         /* force 1000, set loopback */
1244         e1000_write_phy_reg(hw, PHY_CTRL, 0x4140);
1245
1246         /* Now set up the MAC to the same speed/duplex as the PHY. */
1247         ctrl_reg = er32(CTRL);
1248         ctrl_reg &= ~E1000_CTRL_SPD_SEL; /* Clear the speed sel bits */
1249         ctrl_reg |= (E1000_CTRL_FRCSPD | /* Set the Force Speed Bit */
1250                         E1000_CTRL_FRCDPX | /* Set the Force Duplex Bit */
1251                         E1000_CTRL_SPD_1000 |/* Force Speed to 1000 */
1252                         E1000_CTRL_FD); /* Force Duplex to FULL */
1253
1254         if (hw->media_type == e1000_media_type_copper &&
1255             hw->phy_type == e1000_phy_m88)
1256                 ctrl_reg |= E1000_CTRL_ILOS; /* Invert Loss of Signal */
1257         else {
1258                 /* Set the ILOS bit on the fiber Nic is half
1259                  * duplex link is detected.
1260                  */
1261                 stat_reg = er32(STATUS);
1262                 if ((stat_reg & E1000_STATUS_FD) == 0)
1263                         ctrl_reg |= (E1000_CTRL_ILOS | E1000_CTRL_SLU);
1264         }
1265
1266         ew32(CTRL, ctrl_reg);
1267
1268         /* Disable the receiver on the PHY so when a cable is plugged in, the
1269          * PHY does not begin to autoneg when a cable is reconnected to the NIC.
1270          */
1271         if (hw->phy_type == e1000_phy_m88)
1272                 e1000_phy_disable_receiver(adapter);
1273
1274         udelay(500);
1275
1276         return 0;
1277 }
1278
1279 static int e1000_set_phy_loopback(struct e1000_adapter *adapter)
1280 {
1281         struct e1000_hw *hw = &adapter->hw;
1282         u16 phy_reg = 0;
1283         u16 count = 0;
1284
1285         switch (hw->mac_type) {
1286         case e1000_82543:
1287                 if (hw->media_type == e1000_media_type_copper) {
1288                         /* Attempt to setup Loopback mode on Non-integrated PHY.
1289                          * Some PHY registers get corrupted at random, so
1290                          * attempt this 10 times.
1291                          */
1292                         while (e1000_nonintegrated_phy_loopback(adapter) &&
1293                                count++ < 10);
1294                         if (count < 11)
1295                                 return 0;
1296                 }
1297                 break;
1298
1299         case e1000_82544:
1300         case e1000_82540:
1301         case e1000_82545:
1302         case e1000_82545_rev_3:
1303         case e1000_82546:
1304         case e1000_82546_rev_3:
1305         case e1000_82541:
1306         case e1000_82541_rev_2:
1307         case e1000_82547:
1308         case e1000_82547_rev_2:
1309                 return e1000_integrated_phy_loopback(adapter);
1310         default:
1311                 /* Default PHY loopback work is to read the MII
1312                  * control register and assert bit 14 (loopback mode).
1313                  */
1314                 e1000_read_phy_reg(hw, PHY_CTRL, &phy_reg);
1315                 phy_reg |= MII_CR_LOOPBACK;
1316                 e1000_write_phy_reg(hw, PHY_CTRL, phy_reg);
1317                 return 0;
1318         }
1319
1320         return 8;
1321 }
1322
1323 static int e1000_setup_loopback_test(struct e1000_adapter *adapter)
1324 {
1325         struct e1000_hw *hw = &adapter->hw;
1326         u32 rctl;
1327
1328         if (hw->media_type == e1000_media_type_fiber ||
1329             hw->media_type == e1000_media_type_internal_serdes) {
1330                 switch (hw->mac_type) {
1331                 case e1000_82545:
1332                 case e1000_82546:
1333                 case e1000_82545_rev_3:
1334                 case e1000_82546_rev_3:
1335                         return e1000_set_phy_loopback(adapter);
1336                 default:
1337                         rctl = er32(RCTL);
1338                         rctl |= E1000_RCTL_LBM_TCVR;
1339                         ew32(RCTL, rctl);
1340                         return 0;
1341                 }
1342         } else if (hw->media_type == e1000_media_type_copper) {
1343                 return e1000_set_phy_loopback(adapter);
1344         }
1345
1346         return 7;
1347 }
1348
1349 static void e1000_loopback_cleanup(struct e1000_adapter *adapter)
1350 {
1351         struct e1000_hw *hw = &adapter->hw;
1352         u32 rctl;
1353         u16 phy_reg;
1354
1355         rctl = er32(RCTL);
1356         rctl &= ~(E1000_RCTL_LBM_TCVR | E1000_RCTL_LBM_MAC);
1357         ew32(RCTL, rctl);
1358
1359         switch (hw->mac_type) {
1360         case e1000_82545:
1361         case e1000_82546:
1362         case e1000_82545_rev_3:
1363         case e1000_82546_rev_3:
1364         default:
1365                 hw->autoneg = true;
1366                 e1000_read_phy_reg(hw, PHY_CTRL, &phy_reg);
1367                 if (phy_reg & MII_CR_LOOPBACK) {
1368                         phy_reg &= ~MII_CR_LOOPBACK;
1369                         e1000_write_phy_reg(hw, PHY_CTRL, phy_reg);
1370                         e1000_phy_reset(hw);
1371                 }
1372                 break;
1373         }
1374 }
1375
1376 static void e1000_create_lbtest_frame(struct sk_buff *skb,
1377                                       unsigned int frame_size)
1378 {
1379         memset(skb->data, 0xFF, frame_size);
1380         frame_size &= ~1;
1381         memset(&skb->data[frame_size / 2], 0xAA, frame_size / 2 - 1);
1382         memset(&skb->data[frame_size / 2 + 10], 0xBE, 1);
1383         memset(&skb->data[frame_size / 2 + 12], 0xAF, 1);
1384 }
1385
1386 static int e1000_check_lbtest_frame(const unsigned char *data,
1387                                     unsigned int frame_size)
1388 {
1389         frame_size &= ~1;
1390         if (*(data + 3) == 0xFF) {
1391                 if ((*(data + frame_size / 2 + 10) == 0xBE) &&
1392                     (*(data + frame_size / 2 + 12) == 0xAF)) {
1393                         return 0;
1394                 }
1395         }
1396         return 13;
1397 }
1398
1399 static int e1000_run_loopback_test(struct e1000_adapter *adapter)
1400 {
1401         struct e1000_hw *hw = &adapter->hw;
1402         struct e1000_tx_ring *txdr = &adapter->test_tx_ring;
1403         struct e1000_rx_ring *rxdr = &adapter->test_rx_ring;
1404         struct pci_dev *pdev = adapter->pdev;
1405         int i, j, k, l, lc, good_cnt, ret_val = 0;
1406         unsigned long time;
1407
1408         ew32(RDT, rxdr->count - 1);
1409
1410         /* Calculate the loop count based on the largest descriptor ring
1411          * The idea is to wrap the largest ring a number of times using 64
1412          * send/receive pairs during each loop
1413          */
1414
1415         if (rxdr->count <= txdr->count)
1416                 lc = ((txdr->count / 64) * 2) + 1;
1417         else
1418                 lc = ((rxdr->count / 64) * 2) + 1;
1419
1420         k = l = 0;
1421         for (j = 0; j <= lc; j++) { /* loop count loop */
1422                 for (i = 0; i < 64; i++) { /* send the packets */
1423                         e1000_create_lbtest_frame(txdr->buffer_info[i].skb,
1424                                                   1024);
1425                         dma_sync_single_for_device(&pdev->dev,
1426                                                    txdr->buffer_info[k].dma,
1427                                                    txdr->buffer_info[k].length,
1428                                                    DMA_TO_DEVICE);
1429                         if (unlikely(++k == txdr->count))
1430                                 k = 0;
1431                 }
1432                 ew32(TDT, k);
1433                 E1000_WRITE_FLUSH();
1434                 msleep(200);
1435                 time = jiffies; /* set the start time for the receive */
1436                 good_cnt = 0;
1437                 do { /* receive the sent packets */
1438                         dma_sync_single_for_cpu(&pdev->dev,
1439                                                 rxdr->buffer_info[l].dma,
1440                                                 E1000_RXBUFFER_2048,
1441                                                 DMA_FROM_DEVICE);
1442
1443                         ret_val = e1000_check_lbtest_frame(
1444                                         rxdr->buffer_info[l].rxbuf.data +
1445                                         NET_SKB_PAD + NET_IP_ALIGN,
1446                                         1024);
1447                         if (!ret_val)
1448                                 good_cnt++;
1449                         if (unlikely(++l == rxdr->count))
1450                                 l = 0;
1451                         /* time + 20 msecs (200 msecs on 2.4) is more than
1452                          * enough time to complete the receives, if it's
1453                          * exceeded, break and error off
1454                          */
1455                 } while (good_cnt < 64 && time_after(time + 20, jiffies));
1456
1457                 if (good_cnt != 64) {
1458                         ret_val = 13; /* ret_val is the same as mis-compare */
1459                         break;
1460                 }
1461                 if (time_after_eq(jiffies, time + 2)) {
1462                         ret_val = 14; /* error code for time out error */
1463                         break;
1464                 }
1465         } /* end loop count loop */
1466         return ret_val;
1467 }
1468
1469 static int e1000_loopback_test(struct e1000_adapter *adapter, u64 *data)
1470 {
1471         *data = e1000_setup_desc_rings(adapter);
1472         if (*data)
1473                 goto out;
1474         *data = e1000_setup_loopback_test(adapter);
1475         if (*data)
1476                 goto err_loopback;
1477         *data = e1000_run_loopback_test(adapter);
1478         e1000_loopback_cleanup(adapter);
1479
1480 err_loopback:
1481         e1000_free_desc_rings(adapter);
1482 out:
1483         return *data;
1484 }
1485
1486 static int e1000_link_test(struct e1000_adapter *adapter, u64 *data)
1487 {
1488         struct e1000_hw *hw = &adapter->hw;
1489         *data = 0;
1490         if (hw->media_type == e1000_media_type_internal_serdes) {
1491                 int i = 0;
1492
1493                 hw->serdes_has_link = false;
1494
1495                 /* On some blade server designs, link establishment
1496                  * could take as long as 2-3 minutes
1497                  */
1498                 do {
1499                         e1000_check_for_link(hw);
1500                         if (hw->serdes_has_link)
1501                                 return *data;
1502                         msleep(20);
1503                 } while (i++ < 3750);
1504
1505                 *data = 1;
1506         } else {
1507                 e1000_check_for_link(hw);
1508                 if (hw->autoneg)  /* if auto_neg is set wait for it */
1509                         msleep(4000);
1510
1511                 if (!(er32(STATUS) & E1000_STATUS_LU))
1512                         *data = 1;
1513         }
1514         return *data;
1515 }
1516
1517 static int e1000_get_sset_count(struct net_device *netdev, int sset)
1518 {
1519         switch (sset) {
1520         case ETH_SS_TEST:
1521                 return E1000_TEST_LEN;
1522         case ETH_SS_STATS:
1523                 return E1000_STATS_LEN;
1524         default:
1525                 return -EOPNOTSUPP;
1526         }
1527 }
1528
1529 static void e1000_diag_test(struct net_device *netdev,
1530                             struct ethtool_test *eth_test, u64 *data)
1531 {
1532         struct e1000_adapter *adapter = netdev_priv(netdev);
1533         struct e1000_hw *hw = &adapter->hw;
1534         bool if_running = netif_running(netdev);
1535
1536         set_bit(__E1000_TESTING, &adapter->flags);
1537         if (eth_test->flags == ETH_TEST_FL_OFFLINE) {
1538                 /* Offline tests */
1539
1540                 /* save speed, duplex, autoneg settings */
1541                 u16 autoneg_advertised = hw->autoneg_advertised;
1542                 u8 forced_speed_duplex = hw->forced_speed_duplex;
1543                 u8 autoneg = hw->autoneg;
1544
1545                 e_info(hw, "offline testing starting\n");
1546
1547                 /* Link test performed before hardware reset so autoneg doesn't
1548                  * interfere with test result
1549                  */
1550                 if (e1000_link_test(adapter, &data[4]))
1551                         eth_test->flags |= ETH_TEST_FL_FAILED;
1552
1553                 if (if_running)
1554                         /* indicate we're in test mode */
1555                         e1000_close(netdev);
1556                 else
1557                         e1000_reset(adapter);
1558
1559                 if (e1000_reg_test(adapter, &data[0]))
1560                         eth_test->flags |= ETH_TEST_FL_FAILED;
1561
1562                 e1000_reset(adapter);
1563                 if (e1000_eeprom_test(adapter, &data[1]))
1564                         eth_test->flags |= ETH_TEST_FL_FAILED;
1565
1566                 e1000_reset(adapter);
1567                 if (e1000_intr_test(adapter, &data[2]))
1568                         eth_test->flags |= ETH_TEST_FL_FAILED;
1569
1570                 e1000_reset(adapter);
1571                 /* make sure the phy is powered up */
1572                 e1000_power_up_phy(adapter);
1573                 if (e1000_loopback_test(adapter, &data[3]))
1574                         eth_test->flags |= ETH_TEST_FL_FAILED;
1575
1576                 /* restore speed, duplex, autoneg settings */
1577                 hw->autoneg_advertised = autoneg_advertised;
1578                 hw->forced_speed_duplex = forced_speed_duplex;
1579                 hw->autoneg = autoneg;
1580
1581                 e1000_reset(adapter);
1582                 clear_bit(__E1000_TESTING, &adapter->flags);
1583                 if (if_running)
1584                         e1000_open(netdev);
1585         } else {
1586                 e_info(hw, "online testing starting\n");
1587                 /* Online tests */
1588                 if (e1000_link_test(adapter, &data[4]))
1589                         eth_test->flags |= ETH_TEST_FL_FAILED;
1590
1591                 /* Online tests aren't run; pass by default */
1592                 data[0] = 0;
1593                 data[1] = 0;
1594                 data[2] = 0;
1595                 data[3] = 0;
1596
1597                 clear_bit(__E1000_TESTING, &adapter->flags);
1598         }
1599         msleep_interruptible(4 * 1000);
1600 }
1601
1602 static int e1000_wol_exclusion(struct e1000_adapter *adapter,
1603                                struct ethtool_wolinfo *wol)
1604 {
1605         struct e1000_hw *hw = &adapter->hw;
1606         int retval = 1; /* fail by default */
1607
1608         switch (hw->device_id) {
1609         case E1000_DEV_ID_82542:
1610         case E1000_DEV_ID_82543GC_FIBER:
1611         case E1000_DEV_ID_82543GC_COPPER:
1612         case E1000_DEV_ID_82544EI_FIBER:
1613         case E1000_DEV_ID_82546EB_QUAD_COPPER:
1614         case E1000_DEV_ID_82545EM_FIBER:
1615         case E1000_DEV_ID_82545EM_COPPER:
1616         case E1000_DEV_ID_82546GB_QUAD_COPPER:
1617         case E1000_DEV_ID_82546GB_PCIE:
1618                 /* these don't support WoL at all */
1619                 wol->supported = 0;
1620                 break;
1621         case E1000_DEV_ID_82546EB_FIBER:
1622         case E1000_DEV_ID_82546GB_FIBER:
1623                 /* Wake events not supported on port B */
1624                 if (er32(STATUS) & E1000_STATUS_FUNC_1) {
1625                         wol->supported = 0;
1626                         break;
1627                 }
1628                 /* return success for non excluded adapter ports */
1629                 retval = 0;
1630                 break;
1631         case E1000_DEV_ID_82546GB_QUAD_COPPER_KSP3:
1632                 /* quad port adapters only support WoL on port A */
1633                 if (!adapter->quad_port_a) {
1634                         wol->supported = 0;
1635                         break;
1636                 }
1637                 /* return success for non excluded adapter ports */
1638                 retval = 0;
1639                 break;
1640         default:
1641                 /* dual port cards only support WoL on port A from now on
1642                  * unless it was enabled in the eeprom for port B
1643                  * so exclude FUNC_1 ports from having WoL enabled
1644                  */
1645                 if (er32(STATUS) & E1000_STATUS_FUNC_1 &&
1646                     !adapter->eeprom_wol) {
1647                         wol->supported = 0;
1648                         break;
1649                 }
1650
1651                 retval = 0;
1652         }
1653
1654         return retval;
1655 }
1656
1657 static void e1000_get_wol(struct net_device *netdev,
1658                           struct ethtool_wolinfo *wol)
1659 {
1660         struct e1000_adapter *adapter = netdev_priv(netdev);
1661         struct e1000_hw *hw = &adapter->hw;
1662
1663         wol->supported = WAKE_UCAST | WAKE_MCAST | WAKE_BCAST | WAKE_MAGIC;
1664         wol->wolopts = 0;
1665
1666         /* this function will set ->supported = 0 and return 1 if wol is not
1667          * supported by this hardware
1668          */
1669         if (e1000_wol_exclusion(adapter, wol) ||
1670             !device_can_wakeup(&adapter->pdev->dev))
1671                 return;
1672
1673         /* apply any specific unsupported masks here */
1674         switch (hw->device_id) {
1675         case E1000_DEV_ID_82546GB_QUAD_COPPER_KSP3:
1676                 /* KSP3 does not support UCAST wake-ups */
1677                 wol->supported &= ~WAKE_UCAST;
1678
1679                 if (adapter->wol & E1000_WUFC_EX)
1680                         e_err(drv, "Interface does not support directed "
1681                               "(unicast) frame wake-up packets\n");
1682                 break;
1683         default:
1684                 break;
1685         }
1686
1687         if (adapter->wol & E1000_WUFC_EX)
1688                 wol->wolopts |= WAKE_UCAST;
1689         if (adapter->wol & E1000_WUFC_MC)
1690                 wol->wolopts |= WAKE_MCAST;
1691         if (adapter->wol & E1000_WUFC_BC)
1692                 wol->wolopts |= WAKE_BCAST;
1693         if (adapter->wol & E1000_WUFC_MAG)
1694                 wol->wolopts |= WAKE_MAGIC;
1695 }
1696
1697 static int e1000_set_wol(struct net_device *netdev, struct ethtool_wolinfo *wol)
1698 {
1699         struct e1000_adapter *adapter = netdev_priv(netdev);
1700         struct e1000_hw *hw = &adapter->hw;
1701
1702         if (wol->wolopts & (WAKE_PHY | WAKE_ARP | WAKE_MAGICSECURE))
1703                 return -EOPNOTSUPP;
1704
1705         if (e1000_wol_exclusion(adapter, wol) ||
1706             !device_can_wakeup(&adapter->pdev->dev))
1707                 return wol->wolopts ? -EOPNOTSUPP : 0;
1708
1709         switch (hw->device_id) {
1710         case E1000_DEV_ID_82546GB_QUAD_COPPER_KSP3:
1711                 if (wol->wolopts & WAKE_UCAST) {
1712                         e_err(drv, "Interface does not support directed "
1713                               "(unicast) frame wake-up packets\n");
1714                         return -EOPNOTSUPP;
1715                 }
1716                 break;
1717         default:
1718                 break;
1719         }
1720
1721         /* these settings will always override what we currently have */
1722         adapter->wol = 0;
1723
1724         if (wol->wolopts & WAKE_UCAST)
1725                 adapter->wol |= E1000_WUFC_EX;
1726         if (wol->wolopts & WAKE_MCAST)
1727                 adapter->wol |= E1000_WUFC_MC;
1728         if (wol->wolopts & WAKE_BCAST)
1729                 adapter->wol |= E1000_WUFC_BC;
1730         if (wol->wolopts & WAKE_MAGIC)
1731                 adapter->wol |= E1000_WUFC_MAG;
1732
1733         device_set_wakeup_enable(&adapter->pdev->dev, adapter->wol);
1734
1735         return 0;
1736 }
1737
1738 static int e1000_set_phys_id(struct net_device *netdev,
1739                              enum ethtool_phys_id_state state)
1740 {
1741         struct e1000_adapter *adapter = netdev_priv(netdev);
1742         struct e1000_hw *hw = &adapter->hw;
1743
1744         switch (state) {
1745         case ETHTOOL_ID_ACTIVE:
1746                 e1000_setup_led(hw);
1747                 return 2;
1748
1749         case ETHTOOL_ID_ON:
1750                 e1000_led_on(hw);
1751                 break;
1752
1753         case ETHTOOL_ID_OFF:
1754                 e1000_led_off(hw);
1755                 break;
1756
1757         case ETHTOOL_ID_INACTIVE:
1758                 e1000_cleanup_led(hw);
1759         }
1760
1761         return 0;
1762 }
1763
1764 static int e1000_get_coalesce(struct net_device *netdev,
1765                               struct ethtool_coalesce *ec)
1766 {
1767         struct e1000_adapter *adapter = netdev_priv(netdev);
1768
1769         if (adapter->hw.mac_type < e1000_82545)
1770                 return -EOPNOTSUPP;
1771
1772         if (adapter->itr_setting <= 4)
1773                 ec->rx_coalesce_usecs = adapter->itr_setting;
1774         else
1775                 ec->rx_coalesce_usecs = 1000000 / adapter->itr_setting;
1776
1777         return 0;
1778 }
1779
1780 static int e1000_set_coalesce(struct net_device *netdev,
1781                               struct ethtool_coalesce *ec)
1782 {
1783         struct e1000_adapter *adapter = netdev_priv(netdev);
1784         struct e1000_hw *hw = &adapter->hw;
1785
1786         if (hw->mac_type < e1000_82545)
1787                 return -EOPNOTSUPP;
1788
1789         if ((ec->rx_coalesce_usecs > E1000_MAX_ITR_USECS) ||
1790             ((ec->rx_coalesce_usecs > 4) &&
1791              (ec->rx_coalesce_usecs < E1000_MIN_ITR_USECS)) ||
1792             (ec->rx_coalesce_usecs == 2))
1793                 return -EINVAL;
1794
1795         if (ec->rx_coalesce_usecs == 4) {
1796                 adapter->itr = adapter->itr_setting = 4;
1797         } else if (ec->rx_coalesce_usecs <= 3) {
1798                 adapter->itr = 20000;
1799                 adapter->itr_setting = ec->rx_coalesce_usecs;
1800         } else {
1801                 adapter->itr = (1000000 / ec->rx_coalesce_usecs);
1802                 adapter->itr_setting = adapter->itr & ~3;
1803         }
1804
1805         if (adapter->itr_setting != 0)
1806                 ew32(ITR, 1000000000 / (adapter->itr * 256));
1807         else
1808                 ew32(ITR, 0);
1809
1810         return 0;
1811 }
1812
1813 static int e1000_nway_reset(struct net_device *netdev)
1814 {
1815         struct e1000_adapter *adapter = netdev_priv(netdev);
1816
1817         if (netif_running(netdev))
1818                 e1000_reinit_locked(adapter);
1819         return 0;
1820 }
1821
1822 static void e1000_get_ethtool_stats(struct net_device *netdev,
1823                                     struct ethtool_stats *stats, u64 *data)
1824 {
1825         struct e1000_adapter *adapter = netdev_priv(netdev);
1826         int i;
1827         char *p = NULL;
1828         const struct e1000_stats *stat = e1000_gstrings_stats;
1829
1830         e1000_update_stats(adapter);
1831         for (i = 0; i < E1000_GLOBAL_STATS_LEN; i++) {
1832                 switch (stat->type) {
1833                 case NETDEV_STATS:
1834                         p = (char *)netdev + stat->stat_offset;
1835                         break;
1836                 case E1000_STATS:
1837                         p = (char *)adapter + stat->stat_offset;
1838                         break;
1839                 default:
1840                         WARN_ONCE(1, "Invalid E1000 stat type: %u index %d\n",
1841                                   stat->type, i);
1842                         break;
1843                 }
1844
1845                 if (stat->sizeof_stat == sizeof(u64))
1846                         data[i] = *(u64 *)p;
1847                 else
1848                         data[i] = *(u32 *)p;
1849
1850                 stat++;
1851         }
1852 /* BUG_ON(i != E1000_STATS_LEN); */
1853 }
1854
1855 static void e1000_get_strings(struct net_device *netdev, u32 stringset,
1856                               u8 *data)
1857 {
1858         u8 *p = data;
1859         int i;
1860
1861         switch (stringset) {
1862         case ETH_SS_TEST:
1863                 memcpy(data, e1000_gstrings_test, sizeof(e1000_gstrings_test));
1864                 break;
1865         case ETH_SS_STATS:
1866                 for (i = 0; i < E1000_GLOBAL_STATS_LEN; i++) {
1867                         memcpy(p, e1000_gstrings_stats[i].stat_string,
1868                                ETH_GSTRING_LEN);
1869                         p += ETH_GSTRING_LEN;
1870                 }
1871                 /* BUG_ON(p - data != E1000_STATS_LEN * ETH_GSTRING_LEN); */
1872                 break;
1873         }
1874 }
1875
1876 static const struct ethtool_ops e1000_ethtool_ops = {
1877         .get_drvinfo            = e1000_get_drvinfo,
1878         .get_regs_len           = e1000_get_regs_len,
1879         .get_regs               = e1000_get_regs,
1880         .get_wol                = e1000_get_wol,
1881         .set_wol                = e1000_set_wol,
1882         .get_msglevel           = e1000_get_msglevel,
1883         .set_msglevel           = e1000_set_msglevel,
1884         .nway_reset             = e1000_nway_reset,
1885         .get_link               = e1000_get_link,
1886         .get_eeprom_len         = e1000_get_eeprom_len,
1887         .get_eeprom             = e1000_get_eeprom,
1888         .set_eeprom             = e1000_set_eeprom,
1889         .get_ringparam          = e1000_get_ringparam,
1890         .set_ringparam          = e1000_set_ringparam,
1891         .get_pauseparam         = e1000_get_pauseparam,
1892         .set_pauseparam         = e1000_set_pauseparam,
1893         .self_test              = e1000_diag_test,
1894         .get_strings            = e1000_get_strings,
1895         .set_phys_id            = e1000_set_phys_id,
1896         .get_ethtool_stats      = e1000_get_ethtool_stats,
1897         .get_sset_count         = e1000_get_sset_count,
1898         .get_coalesce           = e1000_get_coalesce,
1899         .set_coalesce           = e1000_set_coalesce,
1900         .get_ts_info            = ethtool_op_get_ts_info,
1901         .get_link_ksettings     = e1000_get_link_ksettings,
1902         .set_link_ksettings     = e1000_set_link_ksettings,
1903 };
1904
1905 void e1000_set_ethtool_ops(struct net_device *netdev)
1906 {
1907         netdev->ethtool_ops = &e1000_ethtool_ops;
1908 }