e1000: drop dead pcie code from e1000

this patch is the first in a series of clean up patches for e1000 to drop
unused code, and update the driver to kernel spec, and then, to update the
driver to have all available bug fixes.

Call it the e1000 weight loss plan.

Signed-off-by: Jesse Brandeburg <jesse.brandeburg@intel.com>
Signed-off-by: Don Skidmore <donald.c.skidmore@intel.com>
Signed-off-by: Jeff Kirsher <jeffrey.t.kirsher@intel.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

1 files changed, 60 insertions, 623 deletions

diff --git a/drivers/net/e1000/e1000_main.c b/drivers/net/e1000/e1000_main.c
index c66dd4f9437c..cad6f65fc1e9 100644
--- a/drivers/net/e1000/e1000_main.c
+++ b/drivers/net/e1000/e1000_main.c
@@ -31,7 +31,7 @@
 
 char e1000_driver_name[] = "e1000";
 static char e1000_driver_string[] = "Intel(R) PRO/1000 Network Driver";
-#define DRV_VERSION "7.3.21-k3-NAPI"
+#define DRV_VERSION "7.3.21-k5-NAPI"
 const char e1000_driver_version[] = DRV_VERSION;
 static const char e1000_copyright[] = "Copyright (c) 1999-2006 Intel Corporation.";
 
@@ -131,7 +131,6 @@ static struct net_device_stats * e1000_get_stats(struct net_device *netdev);
 static int e1000_change_mtu(struct net_device *netdev, int new_mtu);
 static int e1000_set_mac(struct net_device *netdev, void *p);
 static irqreturn_t e1000_intr(int irq, void *data);
-static irqreturn_t e1000_intr_msi(int irq, void *data);
 static bool e1000_clean_tx_irq(struct e1000_adapter *adapter,
                                struct e1000_tx_ring *tx_ring);
 static int e1000_clean(struct napi_struct *napi, int budget);
@@ -258,25 +257,14 @@ module_exit(e1000_exit_module);
 
 static int e1000_request_irq(struct e1000_adapter *adapter)
 {
-        struct e1000_hw *hw = &adapter->hw;
         struct net_device *netdev = adapter->netdev;
         irq_handler_t handler = e1000_intr;
         int irq_flags = IRQF_SHARED;
         int err;
 
-        if (hw->mac_type >= e1000_82571) {
-                adapter->have_msi = !pci_enable_msi(adapter->pdev);
-                if (adapter->have_msi) {
-                        handler = e1000_intr_msi;
-                        irq_flags = 0;
-                }
-        }
-
         err = request_irq(adapter->pdev->irq, handler, irq_flags, netdev->name,
                           netdev);
         if (err) {
-                if (adapter->have_msi)
-                        pci_disable_msi(adapter->pdev);
                 DPRINTK(PROBE, ERR,
                         "Unable to allocate interrupt Error: %d\n", err);
         }
@@ -289,9 +277,6 @@ static void e1000_free_irq(struct e1000_adapter *adapter)
         struct net_device *netdev = adapter->netdev;
 
         free_irq(adapter->pdev->irq, netdev);
-
-        if (adapter->have_msi)
-                pci_disable_msi(adapter->pdev);
 }
 
 /**
@@ -345,76 +330,6 @@ static void e1000_update_mng_vlan(struct e1000_adapter *adapter)
         }
 }
 
-/**
- * e1000_release_hw_control - release control of the h/w to f/w
- * @adapter: address of board private structure
- *
- * e1000_release_hw_control resets {CTRL_EXT|FWSM}:DRV_LOAD bit.
- * For ASF and Pass Through versions of f/w this means that the
- * driver is no longer loaded. For AMT version (only with 82573) i
- * of the f/w this means that the network i/f is closed.
- *
- **/
-
-static void e1000_release_hw_control(struct e1000_adapter *adapter)
-{
-        u32 ctrl_ext;
-        u32 swsm;
-        struct e1000_hw *hw = &adapter->hw;
-
-        /* Let firmware taken over control of h/w */
-        switch (hw->mac_type) {
-        case e1000_82573:
-                swsm = er32(SWSM);
-                ew32(SWSM, swsm & ~E1000_SWSM_DRV_LOAD);
-                break;
-        case e1000_82571:
-        case e1000_82572:
-        case e1000_80003es2lan:
-        case e1000_ich8lan:
-                ctrl_ext = er32(CTRL_EXT);
-                ew32(CTRL_EXT, ctrl_ext & ~E1000_CTRL_EXT_DRV_LOAD);
-                break;
-        default:
-                break;
-        }
-}
-
-/**
- * e1000_get_hw_control - get control of the h/w from f/w
- * @adapter: address of board private structure
- *
- * e1000_get_hw_control sets {CTRL_EXT|FWSM}:DRV_LOAD bit.
- * For ASF and Pass Through versions of f/w this means that
- * the driver is loaded. For AMT version (only with 82573)
- * of the f/w this means that the network i/f is open.
- *
- **/
-
-static void e1000_get_hw_control(struct e1000_adapter *adapter)
-{
-        u32 ctrl_ext;
-        u32 swsm;
-        struct e1000_hw *hw = &adapter->hw;
-
-        /* Let firmware know the driver has taken over */
-        switch (hw->mac_type) {
-        case e1000_82573:
-                swsm = er32(SWSM);
-                ew32(SWSM, swsm | E1000_SWSM_DRV_LOAD);
-                break;
-        case e1000_82571:
-        case e1000_82572:
-        case e1000_80003es2lan:
-        case e1000_ich8lan:
-                ctrl_ext = er32(CTRL_EXT);
-                ew32(CTRL_EXT, ctrl_ext | E1000_CTRL_EXT_DRV_LOAD);
-                break;
-        default:
-                break;
-        }
-}
-
 static void e1000_init_manageability(struct e1000_adapter *adapter)
 {
         struct e1000_hw *hw = &adapter->hw;
@@ -425,20 +340,6 @@ static void e1000_init_manageability(struct e1000_adapter *adapter)
                 /* disable hardware interception of ARP */
                 manc &= ~(E1000_MANC_ARP_EN);
 
-                /* enable receiving management packets to the host */
-                /* this will probably generate destination unreachable messages
-                 * from the host OS, but the packets will be handled on SMBUS */
-                if (hw->has_manc2h) {
-                        u32 manc2h = er32(MANC2H);
-
-                        manc |= E1000_MANC_EN_MNG2HOST;
-#define E1000_MNG2HOST_PORT_623 (1 << 5)
-#define E1000_MNG2HOST_PORT_664 (1 << 6)
-                        manc2h |= E1000_MNG2HOST_PORT_623;
-                        manc2h |= E1000_MNG2HOST_PORT_664;
-                        ew32(MANC2H, manc2h);
-                }
-
                 ew32(MANC, manc);
         }
 }
@@ -453,12 +354,6 @@ static void e1000_release_manageability(struct e1000_adapter *adapter)
                 /* re-enable hardware interception of ARP */
                 manc |= E1000_MANC_ARP_EN;
 
-                if (hw->has_manc2h)
-                        manc &= ~E1000_MANC_EN_MNG2HOST;
-
-                /* don't explicitly have to mess with MANC2H since
-                 * MANC has an enable disable that gates MANC2H */
-
                 ew32(MANC, manc);
         }
 }
@@ -563,15 +458,6 @@ static void e1000_power_down_phy(struct e1000_adapter *adapter)
                         if (er32(MANC) & E1000_MANC_SMBUS_EN)
                                 goto out;
                         break;
-                case e1000_82571:
-                case e1000_82572:
-                case e1000_82573:
-                case e1000_80003es2lan:
-                case e1000_ich8lan:
-                        if (e1000_check_mng_mode(hw) ||
-                            e1000_check_phy_reset_block(hw))
-                                goto out;
-                        break;
                 default:
                         goto out;
                 }
@@ -671,16 +557,6 @@ void e1000_reset(struct e1000_adapter *adapter)
                 legacy_pba_adjust = true;
                 pba = E1000_PBA_30K;
                 break;
-        case e1000_82571:
-        case e1000_82572:
-        case e1000_80003es2lan:
-                pba = E1000_PBA_38K;
-                break;
-        case e1000_82573:
-                pba = E1000_PBA_20K;
-                break;
-        case e1000_ich8lan:
-                pba = E1000_PBA_8K;
         case e1000_undefined:
         case e1000_num_macs:
                 break;
@@ -744,16 +620,8 @@ void e1000_reset(struct e1000_adapter *adapter)
 
                         /* if short on rx space, rx wins and must trump tx
                          * adjustment or use Early Receive if available */
-                        if (pba < min_rx_space) {
-                                switch (hw->mac_type) {
-                                case e1000_82573:
-                                        /* ERT enabled in e1000_configure_rx */
-                                        break;
-                                default:
-                                        pba = min_rx_space;
-                                        break;
-                                }
-                        }
+                        if (pba < min_rx_space)
+                                pba = min_rx_space;
                 }
         }
 
@@ -789,7 +657,6 @@ void e1000_reset(struct e1000_adapter *adapter)
 
         /* if (adapter->hwflags & HWFLAGS_PHY_PWR_BIT) { */
         if (hw->mac_type >= e1000_82544 &&
-            hw->mac_type <= e1000_82547_rev_2 &&
             hw->autoneg == 1 &&
             hw->autoneg_advertised == ADVERTISE_1000_FULL) {
                 u32 ctrl = er32(CTRL);
@@ -806,20 +673,6 @@ void e1000_reset(struct e1000_adapter *adapter)
         e1000_reset_adaptive(hw);
         e1000_phy_get_info(hw, &adapter->phy_info);
 
-        if (!adapter->smart_power_down &&
-            (hw->mac_type == e1000_82571 ||
-             hw->mac_type == e1000_82572)) {
-                u16 phy_data = 0;
-                /* speed up time to link by disabling smart power down, ignore
-                 * the return value of this function because there is nothing
-                 * different we would do if it failed */
-                e1000_read_phy_reg(hw, IGP02E1000_PHY_POWER_MGMT,
-                                   &phy_data);
-                phy_data &= ~IGP02E1000_PM_SPD;
-                e1000_write_phy_reg(hw, IGP02E1000_PHY_POWER_MGMT,
-                                    phy_data);
-        }
-
         e1000_release_manageability(adapter);
 }
 
@@ -1046,17 +899,6 @@ static int __devinit e1000_probe(struct pci_dev *pdev,
                 goto err_sw_init;
 
         err = -EIO;
-        /* Flash BAR mapping must happen after e1000_sw_init
-         * because it depends on mac_type */
-        if ((hw->mac_type == e1000_ich8lan) &&
-           (pci_resource_flags(pdev, 1) & IORESOURCE_MEM)) {
-                hw->flash_address = pci_ioremap_bar(pdev, 1);
-                if (!hw->flash_address)
-                        goto err_flashmap;
-        }
-
-        if (e1000_check_phy_reset_block(hw))
-                DPRINTK(PROBE, INFO, "PHY reset is blocked due to SOL/IDER session.\n");
 
         if (hw->mac_type >= e1000_82543) {
                 netdev->features = NETIF_F_SG |
@@ -1064,21 +906,16 @@ static int __devinit e1000_probe(struct pci_dev *pdev,
                                    NETIF_F_HW_VLAN_TX |
                                    NETIF_F_HW_VLAN_RX |
                                    NETIF_F_HW_VLAN_FILTER;
-                if (hw->mac_type == e1000_ich8lan)
-                        netdev->features &= ~NETIF_F_HW_VLAN_FILTER;
         }
 
         if ((hw->mac_type >= e1000_82544) &&
            (hw->mac_type != e1000_82547))
                 netdev->features |= NETIF_F_TSO;
 
-        if (hw->mac_type > e1000_82547_rev_2)
-                netdev->features |= NETIF_F_TSO6;
         if (pci_using_dac)
                 netdev->features |= NETIF_F_HIGHDMA;
 
         netdev->vlan_features |= NETIF_F_TSO;
-        netdev->vlan_features |= NETIF_F_TSO6;
         netdev->vlan_features |= NETIF_F_HW_CSUM;
         netdev->vlan_features |= NETIF_F_SG;
 
@@ -1153,15 +990,8 @@ static int __devinit e1000_probe(struct pci_dev *pdev,
                         EEPROM_INIT_CONTROL2_REG, 1, &eeprom_data);
                 eeprom_apme_mask = E1000_EEPROM_82544_APM;
                 break;
-        case e1000_ich8lan:
-                e1000_read_eeprom(hw,
-                        EEPROM_INIT_CONTROL1_REG, 1, &eeprom_data);
-                eeprom_apme_mask = E1000_EEPROM_ICH8_APME;
-                break;
         case e1000_82546:
         case e1000_82546_rev_3:
-        case e1000_82571:
-        case e1000_80003es2lan:
                 if (er32(STATUS) & E1000_STATUS_FUNC_1){
                         e1000_read_eeprom(hw,
                                 EEPROM_INIT_CONTROL3_PORT_B, 1, &eeprom_data);
@@ -1185,17 +1015,12 @@ static int __devinit e1000_probe(struct pci_dev *pdev,
                 break;
         case E1000_DEV_ID_82546EB_FIBER:
         case E1000_DEV_ID_82546GB_FIBER:
-        case E1000_DEV_ID_82571EB_FIBER:
                 /* Wake events only supported on port A for dual fiber
                  * regardless of eeprom setting */
                 if (er32(STATUS) & E1000_STATUS_FUNC_1)
                         adapter->eeprom_wol = 0;
                 break;
         case E1000_DEV_ID_82546GB_QUAD_COPPER_KSP3:
-        case E1000_DEV_ID_82571EB_QUAD_COPPER:
-        case E1000_DEV_ID_82571EB_QUAD_FIBER:
-        case E1000_DEV_ID_82571EB_QUAD_COPPER_LOWPROFILE:
-        case E1000_DEV_ID_82571PT_QUAD_COPPER:
                 /* if quad port adapter, disable WoL on all but port A */
                 if (global_quad_port_a != 0)
                         adapter->eeprom_wol = 0;
@@ -1213,39 +1038,18 @@ static int __devinit e1000_probe(struct pci_dev *pdev,
 
         /* print bus type/speed/width info */
         DPRINTK(PROBE, INFO, "(PCI%s:%s:%s) ",
-                ((hw->bus_type == e1000_bus_type_pcix) ? "-X" :
-                 (hw->bus_type == e1000_bus_type_pci_express ? " Express":"")),
-                ((hw->bus_speed == e1000_bus_speed_2500) ? "2.5Gb/s" :
-                 (hw->bus_speed == e1000_bus_speed_133) ? "133MHz" :
+                ((hw->bus_type == e1000_bus_type_pcix) ? "-X" : ""),
+                ((hw->bus_speed == e1000_bus_speed_133) ? "133MHz" :
                  (hw->bus_speed == e1000_bus_speed_120) ? "120MHz" :
                  (hw->bus_speed == e1000_bus_speed_100) ? "100MHz" :
                  (hw->bus_speed == e1000_bus_speed_66) ? "66MHz" : "33MHz"),
-                ((hw->bus_width == e1000_bus_width_64) ? "64-bit" :
-                 (hw->bus_width == e1000_bus_width_pciex_4) ? "Width x4" :
-                 (hw->bus_width == e1000_bus_width_pciex_1) ? "Width x1" :
-                 "32-bit"));
+                ((hw->bus_width == e1000_bus_width_64) ? "64-bit" : "32-bit"));
 
         printk("%pM\n", netdev->dev_addr);
 
-        if (hw->bus_type == e1000_bus_type_pci_express) {
-                DPRINTK(PROBE, WARNING, "This device (id %04x:%04x) will no "
-                        "longer be supported by this driver in the future.\n",
-                        pdev->vendor, pdev->device);
-                DPRINTK(PROBE, WARNING, "please use the \"e1000e\" "
-                        "driver instead.\n");
-        }
-
         /* reset the hardware with the new settings */
         e1000_reset(adapter);
 
-        /* If the controller is 82573 and f/w is AMT, do not set
-         * DRV_LOAD until the interface is up.  For all other cases,
-         * let the f/w know that the h/w is now under the control
-         * of the driver. */
-        if (hw->mac_type != e1000_82573 ||
-            !e1000_check_mng_mode(hw))
-                e1000_get_hw_control(adapter);
-
         strcpy(netdev->name, "eth%d");
         err = register_netdev(netdev);
         if (err)
@@ -1260,14 +1064,11 @@ static int __devinit e1000_probe(struct pci_dev *pdev,
         return 0;
 
 err_register:
-        e1000_release_hw_control(adapter);
 err_eeprom:
-        if (!e1000_check_phy_reset_block(hw))
-                e1000_phy_hw_reset(hw);
+        e1000_phy_hw_reset(hw);
 
         if (hw->flash_address)
                 iounmap(hw->flash_address);
-err_flashmap:
         kfree(adapter->tx_ring);
         kfree(adapter->rx_ring);
 err_sw_init:
@@ -1302,14 +1103,9 @@ static void __devexit e1000_remove(struct pci_dev *pdev)
 
         e1000_release_manageability(adapter);
 
-        /* Release control of h/w to f/w.  If f/w is AMT enabled, this
-         * would have already happened in close and is redundant. */
-        e1000_release_hw_control(adapter);
-
         unregister_netdev(netdev);
 
-        if (!e1000_check_phy_reset_block(hw))
-                e1000_phy_hw_reset(hw);
+        e1000_phy_hw_reset(hw);
 
         kfree(adapter->tx_ring);
         kfree(adapter->rx_ring);
@@ -1472,12 +1268,6 @@ static int e1000_open(struct net_device *netdev)
                 e1000_update_mng_vlan(adapter);
         }
 
-        /* If AMT is enabled, let the firmware know that the network
-         * interface is now open */
-        if (hw->mac_type == e1000_82573 &&
-            e1000_check_mng_mode(hw))
-                e1000_get_hw_control(adapter);
-
         /* before we allocate an interrupt, we must be ready to handle it.
          * Setting DEBUG_SHIRQ in the kernel makes it fire an interrupt
          * as soon as we call pci_request_irq, so we have to setup our
@@ -1503,7 +1293,6 @@ static int e1000_open(struct net_device *netdev)
         return E1000_SUCCESS;
 
 err_req_irq:
-        e1000_release_hw_control(adapter);
         e1000_power_down_phy(adapter);
         e1000_free_all_rx_resources(adapter);
 err_setup_rx:
@@ -1548,12 +1337,6 @@ static int e1000_close(struct net_device *netdev)
                 e1000_vlan_rx_kill_vid(netdev, adapter->mng_vlan_id);
         }
 
-        /* If AMT is enabled, let the firmware know that the network
-         * interface is now closed */
-        if (hw->mac_type == e1000_82573 &&
-            e1000_check_mng_mode(hw))
-                e1000_release_hw_control(adapter);
-
         return 0;
 }
 
@@ -1692,7 +1475,7 @@ static void e1000_configure_tx(struct e1000_adapter *adapter)
 {
         u64 tdba;
         struct e1000_hw *hw = &adapter->hw;
-        u32 tdlen, tctl, tipg, tarc;
+        u32 tdlen, tctl, tipg;
         u32 ipgr1, ipgr2;
 
         /* Setup the HW Tx Head and Tail descriptor pointers */
@@ -1714,8 +1497,7 @@ static void e1000_configure_tx(struct e1000_adapter *adapter)
         }
 
         /* Set the default values for the Tx Inter Packet Gap timer */
-        if (hw->mac_type <= e1000_82547_rev_2 &&
-            (hw->media_type == e1000_media_type_fiber ||
+        if ((hw->media_type == e1000_media_type_fiber ||
              hw->media_type == e1000_media_type_internal_serdes))
                 tipg = DEFAULT_82543_TIPG_IPGT_FIBER;
         else
@@ -1728,10 +1510,6 @@ static void e1000_configure_tx(struct e1000_adapter *adapter)
                 ipgr1 = DEFAULT_82542_TIPG_IPGR1;
                 ipgr2 = DEFAULT_82542_TIPG_IPGR2;
                 break;
-        case e1000_80003es2lan:
-                ipgr1 = DEFAULT_82543_TIPG_IPGR1;
-                ipgr2 = DEFAULT_80003ES2LAN_TIPG_IPGR2;
-                break;
         default:
                 ipgr1 = DEFAULT_82543_TIPG_IPGR1;
                 ipgr2 = DEFAULT_82543_TIPG_IPGR2;
@@ -1754,21 +1532,6 @@ static void e1000_configure_tx(struct e1000_adapter *adapter)
         tctl |= E1000_TCTL_PSP | E1000_TCTL_RTLC |
                 (E1000_COLLISION_THRESHOLD << E1000_CT_SHIFT);
 
-        if (hw->mac_type == e1000_82571 || hw->mac_type == e1000_82572) {
-                tarc = er32(TARC0);
-                /* set the speed mode bit, we'll clear it if we're not at
-                 * gigabit link later */
-                tarc |= (1 << 21);
-                ew32(TARC0, tarc);
-        } else if (hw->mac_type == e1000_80003es2lan) {
-                tarc = er32(TARC0);
-                tarc |= 1;
-                ew32(TARC0, tarc);
-                tarc = er32(TARC1);
-                tarc |= 1;
-                ew32(TARC1, tarc);
-        }
-
         e1000_config_collision_dist(hw);
 
         /* Setup Transmit Descriptor Settings for eop descriptor */
@@ -1804,7 +1567,6 @@ static void e1000_configure_tx(struct e1000_adapter *adapter)
 static int e1000_setup_rx_resources(struct e1000_adapter *adapter,
                                     struct e1000_rx_ring *rxdr)
 {
-        struct e1000_hw *hw = &adapter->hw;
         struct pci_dev *pdev = adapter->pdev;
         int size, desc_len;
 
@@ -1817,10 +1579,7 @@ static int e1000_setup_rx_resources(struct e1000_adapter *adapter,
         }
         memset(rxdr->buffer_info, 0, size);
 
-        if (hw->mac_type <= e1000_82547_rev_2)
-                desc_len = sizeof(struct e1000_rx_desc);
-        else
-                desc_len = sizeof(union e1000_rx_desc_packet_split);
+        desc_len = sizeof(struct e1000_rx_desc);
 
         /* Round up to nearest 4K */
 
@@ -1977,7 +1736,7 @@ static void e1000_configure_rx(struct e1000_adapter *adapter)
 {
         u64 rdba;
         struct e1000_hw *hw = &adapter->hw;
-        u32 rdlen, rctl, rxcsum, ctrl_ext;
+        u32 rdlen, rctl, rxcsum;
 
         if (adapter->netdev->mtu > ETH_DATA_LEN) {
                 rdlen = adapter->rx_ring[0].count *
@@ -2004,17 +1763,6 @@ static void e1000_configure_rx(struct e1000_adapter *adapter)
                         ew32(ITR, 1000000000 / (adapter->itr * 256));
         }
 
-        if (hw->mac_type >= e1000_82571) {
-                ctrl_ext = er32(CTRL_EXT);
-                /* Reset delay timers after every interrupt */
-                ctrl_ext |= E1000_CTRL_EXT_INT_TIMER_CLR;
-                /* Auto-Mask interrupts upon ICR access */
-                ctrl_ext |= E1000_CTRL_EXT_IAME;
-                ew32(IAM, 0xffffffff);
-                ew32(CTRL_EXT, ctrl_ext);
-                E1000_WRITE_FLUSH();
-        }
-
         /* Setup the HW Rx Head and Tail Descriptor Pointers and
          * the Base and Length of the Rx Descriptor Ring */
         switch (adapter->num_rx_queues) {
@@ -2329,22 +2077,6 @@ static int e1000_set_mac(struct net_device *netdev, void *p)
 
         e1000_rar_set(hw, hw->mac_addr, 0);
 
-        /* With 82571 controllers, LAA may be overwritten (with the default)
-         * due to controller reset from the other port. */
-        if (hw->mac_type == e1000_82571) {
-                /* activate the work around */
-                hw->laa_is_present = 1;
-
-                /* Hold a copy of the LAA in RAR[14] This is done so that
-                 * between the time RAR[0] gets clobbered  and the time it
-                 * gets fixed (in e1000_watchdog), the actual LAA is in one
-                 * of the RARs and no incoming packets directed to this port
-                 * are dropped. Eventaully the LAA will be in RAR[0] and
-                 * RAR[14] */
-                e1000_rar_set(hw, hw->mac_addr,
-                                        E1000_RAR_ENTRIES - 1);
-        }
-
         if (hw->mac_type == e1000_82542_rev2_0)
                 e1000_leave_82542_rst(adapter);
 
@@ -2371,9 +2103,7 @@ static void e1000_set_rx_mode(struct net_device *netdev)
         u32 rctl;
         u32 hash_value;
         int i, rar_entries = E1000_RAR_ENTRIES;
-        int mta_reg_count = (hw->mac_type == e1000_ich8lan) ?
-                                E1000_NUM_MTA_REGISTERS_ICH8LAN :
-                                E1000_NUM_MTA_REGISTERS;
+        int mta_reg_count = E1000_NUM_MTA_REGISTERS;
         u32 *mcarray = kcalloc(mta_reg_count, sizeof(u32), GFP_ATOMIC);
 
         if (!mcarray) {
@@ -2381,13 +2111,6 @@ static void e1000_set_rx_mode(struct net_device *netdev)
                 return;
         }
 
-        if (hw->mac_type == e1000_ich8lan)
-                rar_entries = E1000_RAR_ENTRIES_ICH8LAN;
-
-        /* reserve RAR[14] for LAA over-write work-around */
-        if (hw->mac_type == e1000_82571)
-                rar_entries--;
-
         /* Check for Promiscuous and All Multicast modes */
 
         rctl = er32(RCTL);
@@ -2396,15 +2119,13 @@ static void e1000_set_rx_mode(struct net_device *netdev)
                 rctl |= (E1000_RCTL_UPE | E1000_RCTL_MPE);
                 rctl &= ~E1000_RCTL_VFE;
         } else {
-                if (netdev->flags & IFF_ALLMULTI) {
+                if (netdev->flags & IFF_ALLMULTI)
                         rctl |= E1000_RCTL_MPE;
-                } else {
+                else
                         rctl &= ~E1000_RCTL_MPE;
-                }
-                if (adapter->hw.mac_type != e1000_ich8lan)
-                        /* Enable VLAN filter if there is a VLAN */
-                        if (adapter->vlgrp)
-                                rctl |= E1000_RCTL_VFE;
+                /* Enable VLAN filter if there is a VLAN */
+                if (adapter->vlgrp)
+                        rctl |= E1000_RCTL_VFE;
         }
 
         if (netdev->uc.count > rar_entries - 1) {
@@ -2427,7 +2148,6 @@ static void e1000_set_rx_mode(struct net_device *netdev)
          *
          * RAR 0 is used for the station MAC adddress
          * if there are not 14 addresses, go ahead and clear the filters
-         * -- with 82571 controllers only 0-13 entries are filled here
          */
         i = 1;
         if (use_uc)
@@ -2538,22 +2258,8 @@ static void e1000_watchdog(unsigned long data)
         struct net_device *netdev = adapter->netdev;
         struct e1000_tx_ring *txdr = adapter->tx_ring;
         u32 link, tctl;
-        s32 ret_val;
-
-        ret_val = e1000_check_for_link(hw);
-        if ((ret_val == E1000_ERR_PHY) &&
-            (hw->phy_type == e1000_phy_igp_3) &&
-            (er32(CTRL) & E1000_PHY_CTRL_GBE_DISABLE)) {
-                /* See e1000_kumeran_lock_loss_workaround() */
-                DPRINTK(LINK, INFO,
-                        "Gigabit has been disabled, downgrading speed\n");
-        }
 
-        if (hw->mac_type == e1000_82573) {
-                e1000_enable_tx_pkt_filtering(hw);
-                if (adapter->mng_vlan_id != hw->mng_cookie.vlan_id)
-                        e1000_update_mng_vlan(adapter);
-        }
+        e1000_check_for_link(hw);
 
         if ((hw->media_type == e1000_media_type_internal_serdes) &&
            !(er32(TXCW) & E1000_TXCW_ANE))
@@ -2598,52 +2304,15 @@ static void e1000_watchdog(unsigned long data)
                                 break;
                         }
 
-                        if ((hw->mac_type == e1000_82571 ||
-                             hw->mac_type == e1000_82572) &&
-                            !txb2b) {
-                                u32 tarc0;
-                                tarc0 = er32(TARC0);
-                                tarc0 &= ~(1 << 21);
-                                ew32(TARC0, tarc0);
-                        }
-
-                        /* disable TSO for pcie and 10/100 speeds, to avoid
-                         * some hardware issues */
-                        if (!adapter->tso_force &&
-                            hw->bus_type == e1000_bus_type_pci_express){
-                                switch (adapter->link_speed) {
-                                case SPEED_10:
-                                case SPEED_100:
-                                        DPRINTK(PROBE,INFO,
-                                        "10/100 speed: disabling TSO\n");
-                                        netdev->features &= ~NETIF_F_TSO;
-                                        netdev->features &= ~NETIF_F_TSO6;
-                                        break;
-                                case SPEED_1000:
-                                        netdev->features |= NETIF_F_TSO;
-                                        netdev->features |= NETIF_F_TSO6;
-                                        break;
-                                default:
-                                        /* oops */
-                                        break;
-                                }
-                        }
-
-                        /* enable transmits in the hardware, need to do this
-                         * after setting TARC0 */
+                        /* enable transmits in the hardware */
                         tctl = er32(TCTL);
                         tctl |= E1000_TCTL_EN;
                         ew32(TCTL, tctl);
 
                         netif_carrier_on(netdev);
-                        mod_timer(&adapter->phy_info_timer, round_jiffies(jiffies + 2 * HZ));
+                        mod_timer(&adapter->phy_info_timer,
+                                  round_jiffies(jiffies + 2 * HZ));
                         adapter->smartspeed = 0;
-                } else {
-                        /* make sure the receive unit is started */
-                        if (hw->rx_needs_kicking) {
-                                u32 rctl = er32(RCTL);
-                                ew32(RCTL, rctl | E1000_RCTL_EN);
-                        }
                 }
         } else {
                 if (netif_carrier_ok(netdev)) {
@@ -2652,16 +2321,8 @@ static void e1000_watchdog(unsigned long data)
                         printk(KERN_INFO "e1000: %s NIC Link is Down\n",
                                netdev->name);
                         netif_carrier_off(netdev);
-                        mod_timer(&adapter->phy_info_timer, round_jiffies(jiffies + 2 * HZ));
-
-                        /* 80003ES2LAN workaround--
-                         * For packet buffer work-around on link down event;
-                         * disable receives in the ISR and
-                         * reset device here in the watchdog
-                         */
-                        if (hw->mac_type == e1000_80003es2lan)
-                                /* reset device */
-                                schedule_work(&adapter->reset_task);
+                        mod_timer(&adapter->phy_info_timer,
+                                  round_jiffies(jiffies + 2 * HZ));
                 }
 
                 e1000_smartspeed(adapter);
@@ -2700,11 +2361,6 @@ static void e1000_watchdog(unsigned long data)
         /* Force detection of hung controller every watchdog period */
         adapter->detect_tx_hung = true;
 
-        /* With 82571 controllers, LAA may be overwritten due to controller
-         * reset from the other port. Set the appropriate LAA in RAR[0] */
-        if (hw->mac_type == e1000_82571 && hw->laa_is_present)
-                e1000_rar_set(hw, hw->mac_addr, 0);
-
         /* Reset the timer */
         mod_timer(&adapter->watchdog_timer, round_jiffies(jiffies + 2 * HZ));
 }
@@ -3186,41 +2842,6 @@ no_fifo_stall_required:
         return 0;
 }
 
-#define MINIMUM_DHCP_PACKET_SIZE 282
-static int e1000_transfer_dhcp_info(struct e1000_adapter *adapter,
-                                    struct sk_buff *skb)
-{
-        struct e1000_hw *hw =  &adapter->hw;
-        u16 length, offset;
-        if (vlan_tx_tag_present(skb)) {
-                if (!((vlan_tx_tag_get(skb) == hw->mng_cookie.vlan_id) &&
-                        ( hw->mng_cookie.status &
-                          E1000_MNG_DHCP_COOKIE_STATUS_VLAN_SUPPORT)) )
-                        return 0;
-        }
-        if (skb->len > MINIMUM_DHCP_PACKET_SIZE) {
-                struct ethhdr *eth = (struct ethhdr *)skb->data;
-                if ((htons(ETH_P_IP) == eth->h_proto)) {
-                        const struct iphdr *ip =
-                                (struct iphdr *)((u8 *)skb->data+14);
-                        if (IPPROTO_UDP == ip->protocol) {
-                                struct udphdr *udp =
-                                        (struct udphdr *)((u8 *)ip +
-                                                (ip->ihl << 2));
-                                if (ntohs(udp->dest) == 67) {
-                                        offset = (u8 *)udp + 8 - skb->data;
-                                        length = skb->len - offset;
-
-                                        return e1000_mng_write_dhcp_info(hw,
-                                                        (u8 *)udp + 8,
-                                                        length);
-                                }
-                        }
-                }
-        }
-        return 0;
-}
-
 static int __e1000_maybe_stop_tx(struct net_device *netdev, int size)
 {
         struct e1000_adapter *adapter = netdev_priv(netdev);
@@ -3279,11 +2900,6 @@ static netdev_tx_t e1000_xmit_frame(struct sk_buff *skb,
                 return NETDEV_TX_OK;
         }
 
-        /* 82571 and newer doesn't need the workaround that limited descriptor
-         * length to 4kB */
-        if (hw->mac_type >= e1000_82571)
-                max_per_txd = 8192;
-
         mss = skb_shinfo(skb)->gso_size;
         /* The controller does a simple calculation to
          * make sure there is enough room in the FIFO before
@@ -3296,9 +2912,6 @@ static netdev_tx_t e1000_xmit_frame(struct sk_buff *skb,
                 max_per_txd = min(mss << 2, max_per_txd);
                 max_txd_pwr = fls(max_per_txd) - 1;
 
-                /* TSO Workaround for 82571/2/3 Controllers -- if skb->data
-                * points to just header, pull a few bytes of payload from
-                * frags into skb->data */
                 hdr_len = skb_transport_offset(skb) + tcp_hdrlen(skb);
                 if (skb->data_len && hdr_len == len) {
                         switch (hw->mac_type) {
@@ -3313,10 +2926,6 @@ static netdev_tx_t e1000_xmit_frame(struct sk_buff *skb,
                                 if ((unsigned long)(skb_tail_pointer(skb) - 1) & 4)
                                         break;
                                 /* fall through */
-                        case e1000_82571:
-                        case e1000_82572:
-                        case e1000_82573:
-                        case e1000_ich8lan:
                                 pull_size = min((unsigned int)4, skb->data_len);
                                 if (!__pskb_pull_tail(skb, pull_size)) {
                                         DPRINTK(DRV, ERR,
@@ -3361,11 +2970,6 @@ static netdev_tx_t e1000_xmit_frame(struct sk_buff *skb,
         if (adapter->pcix_82544)
                 count += nr_frags;
 
-
-        if (hw->tx_pkt_filtering &&
-            (hw->mac_type == e1000_82573))
-                e1000_transfer_dhcp_info(adapter, skb);
-
         /* need: count + 2 desc gap to keep tail from touching
          * head, otherwise try next time */
         if (unlikely(e1000_maybe_stop_tx(netdev, tx_ring, count + 2)))
@@ -3398,9 +3002,6 @@ static netdev_tx_t e1000_xmit_frame(struct sk_buff *skb,
         } else if (likely(e1000_tx_csum(adapter, tx_ring, skb)))
                 tx_flags |= E1000_TX_FLAGS_CSUM;
 
-        /* Old method was to assume IPv4 packet by default if TSO was enabled.
-         * 82571 hardware supports TSO capabilities for IPv6 as well...
-         * no longer assume, we must. */
         if (likely(skb->protocol == htons(ETH_P_IP)))
                 tx_flags |= E1000_TX_FLAGS_IPV4;
 
@@ -3472,7 +3073,6 @@ static int e1000_change_mtu(struct net_device *netdev, int new_mtu)
         struct e1000_adapter *adapter = netdev_priv(netdev);
         struct e1000_hw *hw = &adapter->hw;
         int max_frame = new_mtu + ENET_HEADER_SIZE + ETHERNET_FCS_SIZE;
-        u16 eeprom_data = 0;
 
         if ((max_frame < MINIMUM_ETHERNET_FRAME_SIZE) ||
             (max_frame > MAX_JUMBO_FRAME_SIZE)) {
@@ -3483,39 +3083,11 @@ static int e1000_change_mtu(struct net_device *netdev, int new_mtu)
         /* Adapter-specific max frame size limits. */
         switch (hw->mac_type) {
         case e1000_undefined ... e1000_82542_rev2_1:
-        case e1000_ich8lan:
                 if (max_frame > (ETH_FRAME_LEN + ETH_FCS_LEN)) {
                         DPRINTK(PROBE, ERR, "Jumbo Frames not supported.\n");
                         return -EINVAL;
                 }
                 break;
-        case e1000_82573:
-                /* Jumbo Frames not supported if:
-                 * - this is not an 82573L device
-                 * - ASPM is enabled in any way (0x1A bits 3:2) */
-                e1000_read_eeprom(hw, EEPROM_INIT_3GIO_3, 1,
-                                  &eeprom_data);
-                if ((hw->device_id != E1000_DEV_ID_82573L) ||
-                    (eeprom_data & EEPROM_WORD1A_ASPM_MASK)) {
-                        if (max_frame > (ETH_FRAME_LEN + ETH_FCS_LEN)) {
-                                DPRINTK(PROBE, ERR,
-                                        "Jumbo Frames not supported.\n");
-                                return -EINVAL;
-                        }
-                        break;
-                }
-                /* ERT will be enabled later to enable wire speed receives */
-
-                /* fall through to get support */
-        case e1000_82571:
-        case e1000_82572:
-        case e1000_80003es2lan:
-#define MAX_STD_JUMBO_FRAME_SIZE 9234
-                if (max_frame > MAX_STD_JUMBO_FRAME_SIZE) {
-                        DPRINTK(PROBE, ERR, "MTU > 9216 not supported.\n");
-                        return -EINVAL;
-                }
-                break;
         default:
                 /* Capable of supporting up to MAX_JUMBO_FRAME_SIZE limit. */
                 break;
@@ -3596,14 +3168,12 @@ void e1000_update_stats(struct e1000_adapter *adapter)
         adapter->stats.mprc += er32(MPRC);
         adapter->stats.roc += er32(ROC);
 
-        if (hw->mac_type != e1000_ich8lan) {
-                adapter->stats.prc64 += er32(PRC64);
-                adapter->stats.prc127 += er32(PRC127);
-                adapter->stats.prc255 += er32(PRC255);
-                adapter->stats.prc511 += er32(PRC511);
-                adapter->stats.prc1023 += er32(PRC1023);
-                adapter->stats.prc1522 += er32(PRC1522);
-        }
+        adapter->stats.prc64 += er32(PRC64);
+        adapter->stats.prc127 += er32(PRC127);
+        adapter->stats.prc255 += er32(PRC255);
+        adapter->stats.prc511 += er32(PRC511);
+        adapter->stats.prc1023 += er32(PRC1023);
+        adapter->stats.prc1522 += er32(PRC1522);
 
         adapter->stats.symerrs += er32(SYMERRS);
         adapter->stats.mpc += er32(MPC);
@@ -3632,14 +3202,12 @@ void e1000_update_stats(struct e1000_adapter *adapter)
         adapter->stats.toth += er32(TOTH);
         adapter->stats.tpr += er32(TPR);
 
-        if (hw->mac_type != e1000_ich8lan) {
-                adapter->stats.ptc64 += er32(PTC64);
-                adapter->stats.ptc127 += er32(PTC127);
-                adapter->stats.ptc255 += er32(PTC255);
-                adapter->stats.ptc511 += er32(PTC511);
-                adapter->stats.ptc1023 += er32(PTC1023);
-                adapter->stats.ptc1522 += er32(PTC1522);
-        }
+        adapter->stats.ptc64 += er32(PTC64);
+        adapter->stats.ptc127 += er32(PTC127);
+        adapter->stats.ptc255 += er32(PTC255);
+        adapter->stats.ptc511 += er32(PTC511);
+        adapter->stats.ptc1023 += er32(PTC1023);
+        adapter->stats.ptc1522 += er32(PTC1522);
 
         adapter->stats.mptc += er32(MPTC);
         adapter->stats.bptc += er32(BPTC);
@@ -3659,20 +3227,6 @@ void e1000_update_stats(struct e1000_adapter *adapter)
                 adapter->stats.tsctc += er32(TSCTC);
                 adapter->stats.tsctfc += er32(TSCTFC);
         }
-        if (hw->mac_type > e1000_82547_rev_2) {
-                adapter->stats.iac += er32(IAC);
-                adapter->stats.icrxoc += er32(ICRXOC);
-
-                if (hw->mac_type != e1000_ich8lan) {
-                        adapter->stats.icrxptc += er32(ICRXPTC);
-                        adapter->stats.icrxatc += er32(ICRXATC);
-                        adapter->stats.ictxptc += er32(ICTXPTC);
-                        adapter->stats.ictxatc += er32(ICTXATC);
-                        adapter->stats.ictxqec += er32(ICTXQEC);
-                        adapter->stats.ictxqmtc += er32(ICTXQMTC);
-                        adapter->stats.icrxdmtc += er32(ICRXDMTC);
-                }
-        }
 
         /* Fill out the OS statistics structure */
         adapter->net_stats.multicast = adapter->stats.mprc;
@@ -3731,49 +3285,6 @@ void e1000_update_stats(struct e1000_adapter *adapter)
 }
 
 /**
- * e1000_intr_msi - Interrupt Handler
- * @irq: interrupt number
- * @data: pointer to a network interface device structure
- **/
-
-static irqreturn_t e1000_intr_msi(int irq, void *data)
-{
-        struct net_device *netdev = data;
-        struct e1000_adapter *adapter = netdev_priv(netdev);
-        struct e1000_hw *hw = &adapter->hw;
-        u32 icr = er32(ICR);
-
-        /* in NAPI mode read ICR disables interrupts using IAM */
-
-        if (icr & (E1000_ICR_RXSEQ | E1000_ICR_LSC)) {
-                hw->get_link_status = 1;
-                /* 80003ES2LAN workaround-- For packet buffer work-around on
-                 * link down event; disable receives here in the ISR and reset
-                 * adapter in watchdog */
-                if (netif_carrier_ok(netdev) &&
-                    (hw->mac_type == e1000_80003es2lan)) {
-                        /* disable receives */
-                        u32 rctl = er32(RCTL);
-                        ew32(RCTL, rctl & ~E1000_RCTL_EN);
-                }
-                /* guard against interrupt when we're going down */
-                if (!test_bit(__E1000_DOWN, &adapter->flags))
-                        mod_timer(&adapter->watchdog_timer, jiffies + 1);
-        }
-
-        if (likely(napi_schedule_prep(&adapter->napi))) {
-                adapter->total_tx_bytes = 0;
-                adapter->total_tx_packets = 0;
-                adapter->total_rx_bytes = 0;
-                adapter->total_rx_packets = 0;
-                __napi_schedule(&adapter->napi);
-        } else
-                e1000_irq_enable(adapter);
-
-        return IRQ_HANDLED;
-}
-
-/**
  * e1000_intr - Interrupt Handler
  * @irq: interrupt number
  * @data: pointer to a network interface device structure
@@ -3784,43 +3295,22 @@ static irqreturn_t e1000_intr(int irq, void *data)
         struct net_device *netdev = data;
         struct e1000_adapter *adapter = netdev_priv(netdev);
         struct e1000_hw *hw = &adapter->hw;
-        u32 rctl, icr = er32(ICR);
+        u32 icr = er32(ICR);
 
         if (unlikely((!icr) || test_bit(__E1000_DOWN, &adapter->flags)))
                 return IRQ_NONE;  /* Not our interrupt */
 
-        /* IMS will not auto-mask if INT_ASSERTED is not set, and if it is
-         * not set, then the adapter didn't send an interrupt */
-        if (unlikely(hw->mac_type >= e1000_82571 &&
-                     !(icr & E1000_ICR_INT_ASSERTED)))
-                return IRQ_NONE;
-
-        /* Interrupt Auto-Mask...upon reading ICR, interrupts are masked.  No
-         * need for the IMC write */
-
         if (unlikely(icr & (E1000_ICR_RXSEQ | E1000_ICR_LSC))) {
                 hw->get_link_status = 1;
-                /* 80003ES2LAN workaround--
-                 * For packet buffer work-around on link down event;
-                 * disable receives here in the ISR and
-                 * reset adapter in watchdog
-                 */
-                if (netif_carrier_ok(netdev) &&
-                    (hw->mac_type == e1000_80003es2lan)) {
-                        /* disable receives */
-                        rctl = er32(RCTL);
-                        ew32(RCTL, rctl & ~E1000_RCTL_EN);
-                }
                 /* guard against interrupt when we're going down */
                 if (!test_bit(__E1000_DOWN, &adapter->flags))
                         mod_timer(&adapter->watchdog_timer, jiffies + 1);
         }
 
-        if (unlikely(hw->mac_type < e1000_82571)) {
-                /* disable interrupts, without the synchronize_irq bit */
-                ew32(IMC, ~0);
-                E1000_WRITE_FLUSH();
-        }
+        /* disable interrupts, without the synchronize_irq bit */
+        ew32(IMC, ~0);
+        E1000_WRITE_FLUSH();
+
         if (likely(napi_schedule_prep(&adapter->napi))) {
                 adapter->total_tx_bytes = 0;
                 adapter->total_tx_packets = 0;
@@ -3999,25 +3489,13 @@ static void e1000_rx_checksum(struct e1000_adapter *adapter, u32 status_err,
                 return;
         }
         /* TCP/UDP Checksum has not been calculated */
-        if (hw->mac_type <= e1000_82547_rev_2) {
-                if (!(status & E1000_RXD_STAT_TCPCS))
-                        return;
-        } else {
-                if (!(status & (E1000_RXD_STAT_TCPCS | E1000_RXD_STAT_UDPCS)))
-                        return;
-        }
+        if (!(status & E1000_RXD_STAT_TCPCS))
+                return;
+
         /* It must be a TCP or UDP packet with a valid checksum */
         if (likely(status & E1000_RXD_STAT_TCPCS)) {
                 /* TCP checksum is good */
                 skb->ip_summed = CHECKSUM_UNNECESSARY;
-        } else if (hw->mac_type > e1000_82547_rev_2) {
-                /* IP fragment with UDP payload */
-                /* Hardware complements the payload checksum, so we undo it
-                 * and then put the value in host order for further stack use.
-                 */
-                __sum16 sum = (__force __sum16)htons(csum);
-                skb->csum = csum_unfold(~sum);
-                skb->ip_summed = CHECKSUM_COMPLETE;
         }
         adapter->hw_csum_good++;
 }
@@ -4850,33 +4328,28 @@ static void e1000_vlan_rx_register(struct net_device *netdev,
                 ctrl |= E1000_CTRL_VME;
                 ew32(CTRL, ctrl);
 
-                if (adapter->hw.mac_type != e1000_ich8lan) {
-                        /* enable VLAN receive filtering */
-                        rctl = er32(RCTL);
-                        rctl &= ~E1000_RCTL_CFIEN;
-                        if (!(netdev->flags & IFF_PROMISC))
-                                rctl |= E1000_RCTL_VFE;
-                        ew32(RCTL, rctl);
-                        e1000_update_mng_vlan(adapter);
-                }
+                /* enable VLAN receive filtering */
+                rctl = er32(RCTL);
+                rctl &= ~E1000_RCTL_CFIEN;
+                if (!(netdev->flags & IFF_PROMISC))
+                        rctl |= E1000_RCTL_VFE;
+                ew32(RCTL, rctl);
+                e1000_update_mng_vlan(adapter);
         } else {
                 /* disable VLAN tag insert/strip */
                 ctrl = er32(CTRL);
                 ctrl &= ~E1000_CTRL_VME;
                 ew32(CTRL, ctrl);
 
-                if (adapter->hw.mac_type != e1000_ich8lan) {
-                        /* disable VLAN receive filtering */
-                        rctl = er32(RCTL);
-                        rctl &= ~E1000_RCTL_VFE;
-                        ew32(RCTL, rctl);
+                /* disable VLAN receive filtering */
+                rctl = er32(RCTL);
+                rctl &= ~E1000_RCTL_VFE;
+                ew32(RCTL, rctl);
 
-                        if (adapter->mng_vlan_id !=
-                            (u16)E1000_MNG_VLAN_NONE) {
-                                e1000_vlan_rx_kill_vid(netdev,
-                                                       adapter->mng_vlan_id);
-                                adapter->mng_vlan_id = E1000_MNG_VLAN_NONE;
-                        }
+                if (adapter->mng_vlan_id != (u16)E1000_MNG_VLAN_NONE) {
+                        e1000_vlan_rx_kill_vid(netdev,
+                                               adapter->mng_vlan_id);
+                        adapter->mng_vlan_id = E1000_MNG_VLAN_NONE;
                 }
         }
 
@@ -4913,14 +4386,6 @@ static void e1000_vlan_rx_kill_vid(struct net_device *netdev, u16 vid)
         if (!test_bit(__E1000_DOWN, &adapter->flags))
                 e1000_irq_enable(adapter);
 
-        if ((hw->mng_cookie.status &
-             E1000_MNG_DHCP_COOKIE_STATUS_VLAN_SUPPORT) &&
-            (vid == adapter->mng_vlan_id)) {
-                /* release control to f/w */
-                e1000_release_hw_control(adapter);
-                return;
-        }
-
         /* remove VID from filter table */
         index = (vid >> 5) & 0x7F;
         vfta = E1000_READ_REG_ARRAY(hw, VFTA, index);
@@ -5031,16 +4496,13 @@ static int __e1000_shutdown(struct pci_dev *pdev, bool *enable_wake)
                 }
 
                 if (hw->media_type == e1000_media_type_fiber ||
-                   hw->media_type == e1000_media_type_internal_serdes) {
+                    hw->media_type == e1000_media_type_internal_serdes) {
                         /* keep the laser running in D3 */
                         ctrl_ext = er32(CTRL_EXT);
                         ctrl_ext |= E1000_CTRL_EXT_SDP7_DATA;
                         ew32(CTRL_EXT, ctrl_ext);
                 }
 
-                /* Allow time for pending master requests to run */
-                e1000_disable_pciex_master(hw);
-
                 ew32(WUC, E1000_WUC_PME_EN);
                 ew32(WUFC, wufc);
         } else {
@@ -5056,16 +4518,9 @@ static int __e1000_shutdown(struct pci_dev *pdev, bool *enable_wake)
         if (adapter->en_mng_pt)
                 *enable_wake = true;
 
-        if (hw->phy_type == e1000_phy_igp_3)
-                e1000_phy_powerdown_workaround(hw);
-
         if (netif_running(netdev))
                 e1000_free_irq(adapter);
 
-        /* Release control of h/w to f/w.  If f/w is AMT enabled, this
-         * would have already happened in close and is redundant. */
-        e1000_release_hw_control(adapter);
-
         pci_disable_device(pdev);
 
         return 0;
@@ -5131,14 +4586,6 @@ static int e1000_resume(struct pci_dev *pdev)
 
         netif_device_attach(netdev);
 
-        /* If the controller is 82573 and f/w is AMT, do not set
-         * DRV_LOAD until the interface is up.  For all other cases,
-         * let the f/w know that the h/w is now under the control
-         * of the driver. */
-        if (hw->mac_type != e1000_82573 ||
-            !e1000_check_mng_mode(hw))
-                e1000_get_hw_control(adapter);
-
         return 0;
 }
 #endif
@@ -5243,7 +4690,6 @@ static void e1000_io_resume(struct pci_dev *pdev)
 {
         struct net_device *netdev = pci_get_drvdata(pdev);
         struct e1000_adapter *adapter = netdev_priv(netdev);
-        struct e1000_hw *hw = &adapter->hw;
 
         e1000_init_manageability(adapter);
 
@@ -5255,15 +4701,6 @@ static void e1000_io_resume(struct pci_dev *pdev)
         }
 
         netif_device_attach(netdev);
-
-        /* If the controller is 82573 and f/w is AMT, do not set
-         * DRV_LOAD until the interface is up.  For all other cases,
-         * let the f/w know that the h/w is now under the control
-         * of the driver. */
-        if (hw->mac_type != e1000_82573 ||
-            !e1000_check_mng_mode(hw))
-                e1000_get_hw_control(adapter);
-
 }
 
 /* e1000_main.c */