3 files changed, 174 insertions, 127 deletions

diff --git a/drivers/net/e1000/e1000.h b/drivers/net/e1000/e1000.h
index 42e2b7e21c29..2f29c2131851 100644
--- a/drivers/net/e1000/e1000.h
+++ b/drivers/net/e1000/e1000.h
@@ -167,6 +167,7 @@ struct e1000_buffer {
         unsigned long time_stamp;
         u16 length;
         u16 next_to_watch;
+        u16 mapped_as_page;
 };
 
 struct e1000_tx_ring {
@@ -260,7 +261,6 @@ struct e1000_adapter {
         /* TX */
         struct e1000_tx_ring *tx_ring;      /* One per active queue */
         unsigned int restart_queue;
-        unsigned long tx_queue_len;
         u32 txd_cmd;
         u32 tx_int_delay;
         u32 tx_abs_int_delay;
@@ -302,7 +302,6 @@ struct e1000_adapter {
         /* OS defined structs */
         struct net_device *netdev;
         struct pci_dev *pdev;
-        struct net_device_stats net_stats;
 
         /* structs defined in e1000_hw.h */
         struct e1000_hw hw;
@@ -326,6 +325,8 @@ struct e1000_adapter {
         /* for ioport free */
         int bars;
         int need_ioport;
+
+        bool discarding;
 };
 
 enum e1000_state_t {
@@ -347,6 +348,7 @@ extern int e1000_setup_all_tx_resources(struct e1000_adapter *adapter);
 extern void e1000_free_all_rx_resources(struct e1000_adapter *adapter);
 extern void e1000_free_all_tx_resources(struct e1000_adapter *adapter);
 extern void e1000_update_stats(struct e1000_adapter *adapter);
+extern bool e1000_has_link(struct e1000_adapter *adapter);
 extern void e1000_power_up_phy(struct e1000_adapter *);
 extern void e1000_set_ethtool_ops(struct net_device *netdev);
 extern void e1000_check_options(struct e1000_adapter *adapter);
diff --git a/drivers/net/e1000/e1000_ethtool.c b/drivers/net/e1000/e1000_ethtool.c
index 490b2b7cd3ab..c67e93117271 100644
--- a/drivers/net/e1000/e1000_ethtool.c
+++ b/drivers/net/e1000/e1000_ethtool.c
@@ -31,14 +31,22 @@
 #include "e1000.h"
 #include <asm/uaccess.h>
 
+enum {NETDEV_STATS, E1000_STATS};
+
 struct e1000_stats {
         char stat_string[ETH_GSTRING_LEN];
+        int type;
         int sizeof_stat;
         int stat_offset;
 };
 
-#define E1000_STAT(m) FIELD_SIZEOF(struct e1000_adapter, m), \
-                      offsetof(struct e1000_adapter, m)
+#define E1000_STAT(m)           E1000_STATS, \
+                                sizeof(((struct e1000_adapter *)0)->m), \
+                                offsetof(struct e1000_adapter, m)
+#define E1000_NETDEV_STAT(m)    NETDEV_STATS, \
+                                sizeof(((struct net_device *)0)->m), \
+                                offsetof(struct net_device, m)
+
 static const struct e1000_stats e1000_gstrings_stats[] = {
         { "rx_packets", E1000_STAT(stats.gprc) },
         { "tx_packets", E1000_STAT(stats.gptc) },
@@ -50,19 +58,19 @@ static const struct e1000_stats e1000_gstrings_stats[] = {
         { "tx_multicast", E1000_STAT(stats.mptc) },
         { "rx_errors", E1000_STAT(stats.rxerrc) },
         { "tx_errors", E1000_STAT(stats.txerrc) },
-        { "tx_dropped", E1000_STAT(net_stats.tx_dropped) },
+        { "tx_dropped", E1000_NETDEV_STAT(stats.tx_dropped) },
         { "multicast", E1000_STAT(stats.mprc) },
         { "collisions", E1000_STAT(stats.colc) },
         { "rx_length_errors", E1000_STAT(stats.rlerrc) },
-        { "rx_over_errors", E1000_STAT(net_stats.rx_over_errors) },
+        { "rx_over_errors", E1000_NETDEV_STAT(stats.rx_over_errors) },
         { "rx_crc_errors", E1000_STAT(stats.crcerrs) },
-        { "rx_frame_errors", E1000_STAT(net_stats.rx_frame_errors) },
+        { "rx_frame_errors", E1000_NETDEV_STAT(stats.rx_frame_errors) },
         { "rx_no_buffer_count", E1000_STAT(stats.rnbc) },
         { "rx_missed_errors", E1000_STAT(stats.mpc) },
         { "tx_aborted_errors", E1000_STAT(stats.ecol) },
         { "tx_carrier_errors", E1000_STAT(stats.tncrs) },
-        { "tx_fifo_errors", E1000_STAT(net_stats.tx_fifo_errors) },
-        { "tx_heartbeat_errors", E1000_STAT(net_stats.tx_heartbeat_errors) },
+        { "tx_fifo_errors", E1000_NETDEV_STAT(stats.tx_fifo_errors) },
+        { "tx_heartbeat_errors", E1000_NETDEV_STAT(stats.tx_heartbeat_errors) },
         { "tx_window_errors", E1000_STAT(stats.latecol) },
         { "tx_abort_late_coll", E1000_STAT(stats.latecol) },
         { "tx_deferred_ok", E1000_STAT(stats.dc) },
@@ -207,6 +215,23 @@ static int e1000_set_settings(struct net_device *netdev,
         return 0;
 }
 
+static u32 e1000_get_link(struct net_device *netdev)
+{
+        struct e1000_adapter *adapter = netdev_priv(netdev);
+
+        /*
+         * If the link is not reported up to netdev, interrupts are disabled,
+         * and so the physical link state may have changed since we last
+         * looked. Set get_link_status to make sure that the true link
+         * state is interrogated, rather than pulling a cached and possibly
+         * stale link state from the driver.
+         */
+        if (!netif_carrier_ok(netdev))
+                adapter->hw.get_link_status = 1;
+
+        return e1000_has_link(adapter);
+}
+
 static void e1000_get_pauseparam(struct net_device *netdev,
                                  struct ethtool_pauseparam *pause)
 {
@@ -861,10 +886,10 @@ static int e1000_intr_test(struct e1000_adapter *adapter, u64 *data)
 
         /* NOTE: we don't test MSI interrupts here, yet */
         /* Hook up test interrupt handler just for this test */
-        if (!request_irq(irq, &e1000_test_intr, IRQF_PROBE_SHARED, netdev->name,
+        if (!request_irq(irq, e1000_test_intr, IRQF_PROBE_SHARED, netdev->name,
                          netdev))
                 shared_int = false;
-        else if (request_irq(irq, &e1000_test_intr, IRQF_SHARED,
+        else if (request_irq(irq, e1000_test_intr, IRQF_SHARED,
                  netdev->name, netdev)) {
                 *data = 1;
                 return -1;
@@ -1830,10 +1855,21 @@ static void e1000_get_ethtool_stats(struct net_device *netdev,
 {
         struct e1000_adapter *adapter = netdev_priv(netdev);
         int i;
+        char *p = NULL;
 
         e1000_update_stats(adapter);
         for (i = 0; i < E1000_GLOBAL_STATS_LEN; i++) {
-                char *p = (char *)adapter+e1000_gstrings_stats[i].stat_offset;
+                switch (e1000_gstrings_stats[i].type) {
+                case NETDEV_STATS:
+                        p = (char *) netdev +
+                                        e1000_gstrings_stats[i].stat_offset;
+                        break;
+                case E1000_STATS:
+                        p = (char *) adapter +
+                                        e1000_gstrings_stats[i].stat_offset;
+                        break;
+                }
+
                 data[i] = (e1000_gstrings_stats[i].sizeof_stat ==
                         sizeof(u64)) ? *(u64 *)p : *(u32 *)p;
         }
@@ -1873,7 +1909,7 @@ static const struct ethtool_ops e1000_ethtool_ops = {
         .get_msglevel           = e1000_get_msglevel,
         .set_msglevel           = e1000_set_msglevel,
         .nway_reset             = e1000_nway_reset,
-        .get_link               = ethtool_op_get_link,
+        .get_link               = e1000_get_link,
         .get_eeprom_len         = e1000_get_eeprom_len,
         .get_eeprom             = e1000_get_eeprom,
         .set_eeprom             = e1000_set_eeprom,
diff --git a/drivers/net/e1000/e1000_main.c b/drivers/net/e1000/e1000_main.c
index bcd192ca47b0..b15ece26ed84 100644
--- a/drivers/net/e1000/e1000_main.c
+++ b/drivers/net/e1000/e1000_main.c
@@ -42,7 +42,7 @@ static const char e1000_copyright[] = "Copyright (c) 1999-2006 Intel Corporation
  * Macro expands to...
  *   {PCI_DEVICE(PCI_VENDOR_ID_INTEL, device_id)}
  */
-static struct pci_device_id e1000_pci_tbl[] = {
+static DEFINE_PCI_DEVICE_TABLE(e1000_pci_tbl) = {
         INTEL_E1000_ETHERNET_DEVICE(0x1000),
         INTEL_E1000_ETHERNET_DEVICE(0x1001),
         INTEL_E1000_ETHERNET_DEVICE(0x1004),
@@ -383,8 +383,6 @@ static void e1000_configure(struct e1000_adapter *adapter)
                 adapter->alloc_rx_buf(adapter, ring,
                                       E1000_DESC_UNUSED(ring));
         }
-
-        adapter->tx_queue_len = netdev->tx_queue_len;
 }
 
 int e1000_up(struct e1000_adapter *adapter)
@@ -503,7 +501,6 @@ void e1000_down(struct e1000_adapter *adapter)
         del_timer_sync(&adapter->watchdog_timer);
         del_timer_sync(&adapter->phy_info_timer);
 
-        netdev->tx_queue_len = adapter->tx_queue_len;
         adapter->link_speed = 0;
         adapter->link_duplex = 0;
         netif_carrier_off(netdev);
@@ -847,6 +844,9 @@ static int __devinit e1000_probe(struct pci_dev *pdev,
                 goto err_pci_reg;
 
         pci_set_master(pdev);
+        err = pci_save_state(pdev);
+        if (err)
+                goto err_alloc_etherdev;
 
         err = -ENOMEM;
         netdev = alloc_etherdev(sizeof(struct e1000_adapter));
@@ -1698,18 +1698,6 @@ static void e1000_setup_rctl(struct e1000_adapter *adapter)
         rctl &= ~E1000_RCTL_SZ_4096;
         rctl |= E1000_RCTL_BSEX;
         switch (adapter->rx_buffer_len) {
-                case E1000_RXBUFFER_256:
-                        rctl |= E1000_RCTL_SZ_256;
-                        rctl &= ~E1000_RCTL_BSEX;
-                        break;
-                case E1000_RXBUFFER_512:
-                        rctl |= E1000_RCTL_SZ_512;
-                        rctl &= ~E1000_RCTL_BSEX;
-                        break;
-                case E1000_RXBUFFER_1024:
-                        rctl |= E1000_RCTL_SZ_1024;
-                        rctl &= ~E1000_RCTL_BSEX;
-                        break;
                 case E1000_RXBUFFER_2048:
                 default:
                         rctl |= E1000_RCTL_SZ_2048;
@@ -1839,10 +1827,17 @@ void e1000_free_all_tx_resources(struct e1000_adapter *adapter)
 static void e1000_unmap_and_free_tx_resource(struct e1000_adapter *adapter,
                                              struct e1000_buffer *buffer_info)
 {
-        buffer_info->dma = 0;
+        if (buffer_info->dma) {
+                if (buffer_info->mapped_as_page)
+                        pci_unmap_page(adapter->pdev, buffer_info->dma,
+                                       buffer_info->length, PCI_DMA_TODEVICE);
+                else
+                        pci_unmap_single(adapter->pdev, buffer_info->dma,
+                                         buffer_info->length,
+                                         PCI_DMA_TODEVICE);
+                buffer_info->dma = 0;
+        }
         if (buffer_info->skb) {
-                skb_dma_unmap(&adapter->pdev->dev, buffer_info->skb,
-                              DMA_TO_DEVICE);
                 dev_kfree_skb_any(buffer_info->skb);
                 buffer_info->skb = NULL;
         }
@@ -2132,7 +2127,7 @@ static void e1000_set_rx_mode(struct net_device *netdev)
                         rctl |= E1000_RCTL_VFE;
         }
 
-        if (netdev->uc.count > rar_entries - 1) {
+        if (netdev_uc_count(netdev) > rar_entries - 1) {
                 rctl |= E1000_RCTL_UPE;
         } else if (!(netdev->flags & IFF_PROMISC)) {
                 rctl &= ~E1000_RCTL_UPE;
@@ -2155,7 +2150,7 @@ static void e1000_set_rx_mode(struct net_device *netdev)
          */
         i = 1;
         if (use_uc)
-                list_for_each_entry(ha, &netdev->uc.list, list) {
+                netdev_for_each_uc_addr(ha, netdev) {
                         if (i == rar_entries)
                                 break;
                         e1000_rar_set(hw, ha->addr, i++);
@@ -2163,29 +2158,25 @@ static void e1000_set_rx_mode(struct net_device *netdev)
 
         WARN_ON(i == rar_entries);
 
-        mc_ptr = netdev->mc_list;
-
-        for (; i < rar_entries; i++) {
-                if (mc_ptr) {
-                        e1000_rar_set(hw, mc_ptr->da_addr, i);
-                        mc_ptr = mc_ptr->next;
+        netdev_for_each_mc_addr(mc_ptr, netdev) {
+                if (i == rar_entries) {
+                        /* load any remaining addresses into the hash table */
+                        u32 hash_reg, hash_bit, mta;
+                        hash_value = e1000_hash_mc_addr(hw, mc_ptr->da_addr);
+                        hash_reg = (hash_value >> 5) & 0x7F;
+                        hash_bit = hash_value & 0x1F;
+                        mta = (1 << hash_bit);
+                        mcarray[hash_reg] |= mta;
                 } else {
-                        E1000_WRITE_REG_ARRAY(hw, RA, i << 1, 0);
-                        E1000_WRITE_FLUSH();
-                        E1000_WRITE_REG_ARRAY(hw, RA, (i << 1) + 1, 0);
-                        E1000_WRITE_FLUSH();
+                        e1000_rar_set(hw, mc_ptr->da_addr, i++);
                 }
         }
 
-        /* load any remaining addresses into the hash table */
-
-        for (; mc_ptr; mc_ptr = mc_ptr->next) {
-                u32 hash_reg, hash_bit, mta;
-                hash_value = e1000_hash_mc_addr(hw, mc_ptr->da_addr);
-                hash_reg = (hash_value >> 5) & 0x7F;
-                hash_bit = hash_value & 0x1F;
-                mta = (1 << hash_bit);
-                mcarray[hash_reg] |= mta;
+        for (; i < rar_entries; i++) {
+                E1000_WRITE_REG_ARRAY(hw, RA, i << 1, 0);
+                E1000_WRITE_FLUSH();
+                E1000_WRITE_REG_ARRAY(hw, RA, (i << 1) + 1, 0);
+                E1000_WRITE_FLUSH();
         }
 
         /* write the hash table completely, write from bottom to avoid
@@ -2251,7 +2242,7 @@ static void e1000_82547_tx_fifo_stall(unsigned long data)
         }
 }
 
-static bool e1000_has_link(struct e1000_adapter *adapter)
+bool e1000_has_link(struct e1000_adapter *adapter)
 {
         struct e1000_hw *hw = &adapter->hw;
         bool link_active = false;
@@ -2322,19 +2313,15 @@ static void e1000_watchdog(unsigned long data)
                                 E1000_CTRL_RFCE) ? "RX" : ((ctrl &
                                 E1000_CTRL_TFCE) ? "TX" : "None" )));
 
-                        /* tweak tx_queue_len according to speed/duplex
-                         * and adjust the timeout factor */
-                        netdev->tx_queue_len = adapter->tx_queue_len;
+                        /* adjust timeout factor according to speed/duplex */
                         adapter->tx_timeout_factor = 1;
                         switch (adapter->link_speed) {
                         case SPEED_10:
                                 txb2b = false;
-                                netdev->tx_queue_len = 10;
                                 adapter->tx_timeout_factor = 16;
                                 break;
                         case SPEED_100:
                                 txb2b = false;
-                                netdev->tx_queue_len = 100;
                                 /* maybe add some timeout factor ? */
                                 break;
                         }
@@ -2683,22 +2670,14 @@ static int e1000_tx_map(struct e1000_adapter *adapter,
                         unsigned int mss)
 {
         struct e1000_hw *hw = &adapter->hw;
+        struct pci_dev *pdev = adapter->pdev;
         struct e1000_buffer *buffer_info;
         unsigned int len = skb_headlen(skb);
-        unsigned int offset, size, count = 0, i;
+        unsigned int offset = 0, size, count = 0, i;
         unsigned int f;
-        dma_addr_t *map;
 
         i = tx_ring->next_to_use;
 
-        if (skb_dma_map(&adapter->pdev->dev, skb, DMA_TO_DEVICE)) {
-                dev_err(&adapter->pdev->dev, "TX DMA map failed\n");
-                return 0;
-        }
-
-        map = skb_shinfo(skb)->dma_maps;
-        offset = 0;
-
         while (len) {
                 buffer_info = &tx_ring->buffer_info[i];
                 size = min(len, max_per_txd);
@@ -2735,7 +2714,11 @@ static int e1000_tx_map(struct e1000_adapter *adapter,
                 buffer_info->length = size;
                 /* set time_stamp *before* dma to help avoid a possible race */
                 buffer_info->time_stamp = jiffies;
-                buffer_info->dma = skb_shinfo(skb)->dma_head + offset;
+                buffer_info->mapped_as_page = false;
+                buffer_info->dma = pci_map_single(pdev, skb->data + offset,
+                                                  size, PCI_DMA_TODEVICE);
+                if (pci_dma_mapping_error(pdev, buffer_info->dma))
+                        goto dma_error;
                 buffer_info->next_to_watch = i;
 
                 len -= size;
@@ -2753,7 +2736,7 @@ static int e1000_tx_map(struct e1000_adapter *adapter,
 
                 frag = &skb_shinfo(skb)->frags[f];
                 len = frag->size;
-                offset = 0;
+                offset = frag->page_offset;
 
                 while (len) {
                         i++;
@@ -2777,7 +2760,12 @@ static int e1000_tx_map(struct e1000_adapter *adapter,
 
                         buffer_info->length = size;
                         buffer_info->time_stamp = jiffies;
-                        buffer_info->dma = map[f] + offset;
+                        buffer_info->mapped_as_page = true;
+                        buffer_info->dma = pci_map_page(pdev, frag->page,
+                                                        offset, size,
+                                                        PCI_DMA_TODEVICE);
+                        if (pci_dma_mapping_error(pdev, buffer_info->dma))
+                                goto dma_error;
                         buffer_info->next_to_watch = i;
 
                         len -= size;
@@ -2790,6 +2778,22 @@ static int e1000_tx_map(struct e1000_adapter *adapter,
         tx_ring->buffer_info[first].next_to_watch = i;
 
         return count;
+
+dma_error:
+        dev_err(&pdev->dev, "TX DMA map failed\n");
+        buffer_info->dma = 0;
+        if (count)
+                count--;
+
+        while (count--) {
+                if (i==0)
+                        i += tx_ring->count;
+                i--;
+                buffer_info = &tx_ring->buffer_info[i];
+                e1000_unmap_and_free_tx_resource(adapter, buffer_info);
+        }
+
+        return 0;
 }
 
 static void e1000_tx_queue(struct e1000_adapter *adapter,
@@ -3101,10 +3105,8 @@ static void e1000_reset_task(struct work_struct *work)
 
 static struct net_device_stats *e1000_get_stats(struct net_device *netdev)
 {
-        struct e1000_adapter *adapter = netdev_priv(netdev);
-
         /* only return the current stats */
-        return &adapter->net_stats;
+        return &netdev->stats;
 }
 
 /**
@@ -3154,13 +3156,7 @@ static int e1000_change_mtu(struct net_device *netdev, int new_mtu)
          *  however with the new *_jumbo_rx* routines, jumbo receives will use
          *  fragmented skbs */
 
-        if (max_frame <= E1000_RXBUFFER_256)
-                adapter->rx_buffer_len = E1000_RXBUFFER_256;
-        else if (max_frame <= E1000_RXBUFFER_512)
-                adapter->rx_buffer_len = E1000_RXBUFFER_512;
-        else if (max_frame <= E1000_RXBUFFER_1024)
-                adapter->rx_buffer_len = E1000_RXBUFFER_1024;
-        else if (max_frame <= E1000_RXBUFFER_2048)
+        if (max_frame <= E1000_RXBUFFER_2048)
                 adapter->rx_buffer_len = E1000_RXBUFFER_2048;
         else
 #if (PAGE_SIZE >= E1000_RXBUFFER_16384)
@@ -3196,6 +3192,7 @@ static int e1000_change_mtu(struct net_device *netdev, int new_mtu)
 
 void e1000_update_stats(struct e1000_adapter *adapter)
 {
+        struct net_device *netdev = adapter->netdev;
         struct e1000_hw *hw = &adapter->hw;
         struct pci_dev *pdev = adapter->pdev;
         unsigned long flags;
@@ -3288,32 +3285,32 @@ void e1000_update_stats(struct e1000_adapter *adapter)
         }
 
         /* Fill out the OS statistics structure */
-        adapter->net_stats.multicast = adapter->stats.mprc;
-        adapter->net_stats.collisions = adapter->stats.colc;
+        netdev->stats.multicast = adapter->stats.mprc;
+        netdev->stats.collisions = adapter->stats.colc;
 
         /* Rx Errors */
 
         /* RLEC on some newer hardware can be incorrect so build
         * our own version based on RUC and ROC */
-        adapter->net_stats.rx_errors = adapter->stats.rxerrc +
+        netdev->stats.rx_errors = adapter->stats.rxerrc +
                 adapter->stats.crcerrs + adapter->stats.algnerrc +
                 adapter->stats.ruc + adapter->stats.roc +
                 adapter->stats.cexterr;
         adapter->stats.rlerrc = adapter->stats.ruc + adapter->stats.roc;
-        adapter->net_stats.rx_length_errors = adapter->stats.rlerrc;
-        adapter->net_stats.rx_crc_errors = adapter->stats.crcerrs;
-        adapter->net_stats.rx_frame_errors = adapter->stats.algnerrc;
-        adapter->net_stats.rx_missed_errors = adapter->stats.mpc;
+        netdev->stats.rx_length_errors = adapter->stats.rlerrc;
+        netdev->stats.rx_crc_errors = adapter->stats.crcerrs;
+        netdev->stats.rx_frame_errors = adapter->stats.algnerrc;
+        netdev->stats.rx_missed_errors = adapter->stats.mpc;
 
         /* Tx Errors */
         adapter->stats.txerrc = adapter->stats.ecol + adapter->stats.latecol;
-        adapter->net_stats.tx_errors = adapter->stats.txerrc;
-        adapter->net_stats.tx_aborted_errors = adapter->stats.ecol;
-        adapter->net_stats.tx_window_errors = adapter->stats.latecol;
-        adapter->net_stats.tx_carrier_errors = adapter->stats.tncrs;
+        netdev->stats.tx_errors = adapter->stats.txerrc;
+        netdev->stats.tx_aborted_errors = adapter->stats.ecol;
+        netdev->stats.tx_window_errors = adapter->stats.latecol;
+        netdev->stats.tx_carrier_errors = adapter->stats.tncrs;
         if (hw->bad_tx_carr_stats_fd &&
             adapter->link_duplex == FULL_DUPLEX) {
-                adapter->net_stats.tx_carrier_errors = 0;
+                netdev->stats.tx_carrier_errors = 0;
                 adapter->stats.tncrs = 0;
         }
 
@@ -3484,8 +3481,8 @@ static bool e1000_clean_tx_irq(struct e1000_adapter *adapter,
                 adapter->detect_tx_hung = false;
                 if (tx_ring->buffer_info[eop].time_stamp &&
                     time_after(jiffies, tx_ring->buffer_info[eop].time_stamp +
-                               (adapter->tx_timeout_factor * HZ))
-                    && !(er32(STATUS) & E1000_STATUS_TXOFF)) {
+                               (adapter->tx_timeout_factor * HZ)) &&
+                    !(er32(STATUS) & E1000_STATUS_TXOFF)) {
 
                         /* detected Tx unit hang */
                         DPRINTK(DRV, ERR, "Detected Tx Unit Hang\n"
@@ -3514,8 +3511,8 @@ static bool e1000_clean_tx_irq(struct e1000_adapter *adapter,
         }
         adapter->total_tx_bytes += total_tx_bytes;
         adapter->total_tx_packets += total_tx_packets;
-        adapter->net_stats.tx_bytes += total_tx_bytes;
-        adapter->net_stats.tx_packets += total_tx_packets;
+        netdev->stats.tx_bytes += total_tx_bytes;
+        netdev->stats.tx_packets += total_tx_packets;
         return (count < tx_ring->count);
 }
 
@@ -3767,8 +3764,8 @@ next_desc:
 
         adapter->total_rx_packets += total_rx_packets;
         adapter->total_rx_bytes += total_rx_bytes;
-        adapter->net_stats.rx_bytes += total_rx_bytes;
-        adapter->net_stats.rx_packets += total_rx_packets;
+        netdev->stats.rx_bytes += total_rx_bytes;
+        netdev->stats.rx_packets += total_rx_packets;
         return cleaned;
 }
 
@@ -3827,13 +3824,22 @@ static bool e1000_clean_rx_irq(struct e1000_adapter *adapter,
 
                 length = le16_to_cpu(rx_desc->length);
                 /* !EOP means multiple descriptors were used to store a single
-                 * packet, also make sure the frame isn't just CRC only */
-                if (unlikely(!(status & E1000_RXD_STAT_EOP) || (length <= 4))) {
+                 * packet, if thats the case we need to toss it.  In fact, we
+                 * to toss every packet with the EOP bit clear and the next
+                 * frame that _does_ have the EOP bit set, as it is by
+                 * definition only a frame fragment
+                 */
+                if (unlikely(!(status & E1000_RXD_STAT_EOP)))
+                        adapter->discarding = true;
+
+                if (adapter->discarding) {
                         /* All receives must fit into a single buffer */
                         E1000_DBG("%s: Receive packet consumed multiple"
                                   " buffers\n", netdev->name);
                         /* recycle */
                         buffer_info->skb = skb;
+                        if (status & E1000_RXD_STAT_EOP)
+                                adapter->discarding = false;
                         goto next_desc;
                 }
 
@@ -3867,9 +3873,8 @@ static bool e1000_clean_rx_irq(struct e1000_adapter *adapter,
                  * of reassembly being done in the stack */
                 if (length < copybreak) {
                         struct sk_buff *new_skb =
-                            netdev_alloc_skb(netdev, length + NET_IP_ALIGN);
+                            netdev_alloc_skb_ip_align(netdev, length);
                         if (new_skb) {
-                                skb_reserve(new_skb, NET_IP_ALIGN);
                                 skb_copy_to_linear_data_offset(new_skb,
                                                                -NET_IP_ALIGN,
                                                                (skb->data -
@@ -3916,8 +3921,8 @@ next_desc:
 
         adapter->total_rx_packets += total_rx_packets;
         adapter->total_rx_bytes += total_rx_bytes;
-        adapter->net_stats.rx_bytes += total_rx_bytes;
-        adapter->net_stats.rx_packets += total_rx_packets;
+        netdev->stats.rx_bytes += total_rx_bytes;
+        netdev->stats.rx_packets += total_rx_packets;
         return cleaned;
 }
 
@@ -3938,9 +3943,7 @@ e1000_alloc_jumbo_rx_buffers(struct e1000_adapter *adapter,
         struct e1000_buffer *buffer_info;
         struct sk_buff *skb;
         unsigned int i;
-        unsigned int bufsz = 256 -
-                             16 /*for skb_reserve */ -
-                             NET_IP_ALIGN;
+        unsigned int bufsz = 256 - 16 /*for skb_reserve */ ;
 
         i = rx_ring->next_to_use;
         buffer_info = &rx_ring->buffer_info[i];
@@ -3952,7 +3955,7 @@ e1000_alloc_jumbo_rx_buffers(struct e1000_adapter *adapter,
                         goto check_page;
                 }
 
-                skb = netdev_alloc_skb(netdev, bufsz);
+                skb = netdev_alloc_skb_ip_align(netdev, bufsz);
                 if (unlikely(!skb)) {
                         /* Better luck next round */
                         adapter->alloc_rx_buff_failed++;
@@ -3965,7 +3968,7 @@ e1000_alloc_jumbo_rx_buffers(struct e1000_adapter *adapter,
                         DPRINTK(PROBE, ERR, "skb align check failed: %u bytes "
                                              "at %p\n", bufsz, skb->data);
                         /* Try again, without freeing the previous */
-                        skb = netdev_alloc_skb(netdev, bufsz);
+                        skb = netdev_alloc_skb_ip_align(netdev, bufsz);
                         /* Failed allocation, critical failure */
                         if (!skb) {
                                 dev_kfree_skb(oldskb);
@@ -3983,12 +3986,6 @@ e1000_alloc_jumbo_rx_buffers(struct e1000_adapter *adapter,
                         /* Use new allocation */
                         dev_kfree_skb(oldskb);
                 }
-                /* Make buffer alignment 2 beyond a 16 byte boundary
-                 * this will result in a 16 byte aligned IP header after
-                 * the 14 byte MAC header is removed
-                 */
-                skb_reserve(skb, NET_IP_ALIGN);
-
                 buffer_info->skb = skb;
                 buffer_info->length = adapter->rx_buffer_len;
 check_page:
@@ -4001,11 +3998,21 @@ check_page:
                         }
                 }
 
-                if (!buffer_info->dma)
+                if (!buffer_info->dma) {
                         buffer_info->dma = pci_map_page(pdev,
                                                         buffer_info->page, 0,
                                                         buffer_info->length,
                                                         PCI_DMA_FROMDEVICE);
+                        if (pci_dma_mapping_error(pdev, buffer_info->dma)) {
+                                put_page(buffer_info->page);
+                                dev_kfree_skb(skb);
+                                buffer_info->page = NULL;
+                                buffer_info->skb = NULL;
+                                buffer_info->dma = 0;
+                                adapter->alloc_rx_buff_failed++;
+                                break; /* while !buffer_info->skb */
+                        }
+                }
 
                 rx_desc = E1000_RX_DESC(*rx_ring, i);
                 rx_desc->buffer_addr = cpu_to_le64(buffer_info->dma);
@@ -4045,7 +4052,7 @@ static void e1000_alloc_rx_buffers(struct e1000_adapter *adapter,
         struct e1000_buffer *buffer_info;
         struct sk_buff *skb;
         unsigned int i;
-        unsigned int bufsz = adapter->rx_buffer_len + NET_IP_ALIGN;
+        unsigned int bufsz = adapter->rx_buffer_len;
 
         i = rx_ring->next_to_use;
         buffer_info = &rx_ring->buffer_info[i];
@@ -4057,7 +4064,7 @@ static void e1000_alloc_rx_buffers(struct e1000_adapter *adapter,
                         goto map_skb;
                 }
 
-                skb = netdev_alloc_skb(netdev, bufsz);
+                skb = netdev_alloc_skb_ip_align(netdev, bufsz);
                 if (unlikely(!skb)) {
                         /* Better luck next round */
                         adapter->alloc_rx_buff_failed++;
@@ -4070,7 +4077,7 @@ static void e1000_alloc_rx_buffers(struct e1000_adapter *adapter,
                         DPRINTK(RX_ERR, ERR, "skb align check failed: %u bytes "
                                              "at %p\n", bufsz, skb->data);
                         /* Try again, without freeing the previous */
-                        skb = netdev_alloc_skb(netdev, bufsz);
+                        skb = netdev_alloc_skb_ip_align(netdev, bufsz);
                         /* Failed allocation, critical failure */
                         if (!skb) {
                                 dev_kfree_skb(oldskb);
@@ -4089,12 +4096,6 @@ static void e1000_alloc_rx_buffers(struct e1000_adapter *adapter,
                         /* Use new allocation */
                         dev_kfree_skb(oldskb);
                 }
-                /* Make buffer alignment 2 beyond a 16 byte boundary
-                 * this will result in a 16 byte aligned IP header after
-                 * the 14 byte MAC header is removed
-                 */
-                skb_reserve(skb, NET_IP_ALIGN);
-
                 buffer_info->skb = skb;
                 buffer_info->length = adapter->rx_buffer_len;
 map_skb:
@@ -4102,6 +4103,13 @@ map_skb:
                                                   skb->data,
                                                   buffer_info->length,
                                                   PCI_DMA_FROMDEVICE);
+                if (pci_dma_mapping_error(pdev, buffer_info->dma)) {
+                        dev_kfree_skb(skb);
+                        buffer_info->skb = NULL;
+                        buffer_info->dma = 0;
+                        adapter->alloc_rx_buff_failed++;
+                        break; /* while !buffer_info->skb */
+                }
 
                 /*
                  * XXX if it was allocated cleanly it will never map to a
@@ -4597,6 +4605,7 @@ static int e1000_resume(struct pci_dev *pdev)
 
         pci_set_power_state(pdev, PCI_D0);
         pci_restore_state(pdev);
+        pci_save_state(pdev);
 
         if (adapter->need_ioport)
                 err = pci_enable_device(pdev);