1 files changed, 20 insertions, 25 deletions

diff --git a/drivers/net/e1000/e1000_main.c b/drivers/net/e1000/e1000_main.c
index 9267f16b1b32..3a03a74c0609 100644
--- a/drivers/net/e1000/e1000_main.c
+++ b/drivers/net/e1000/e1000_main.c
@@ -748,9 +748,9 @@ e1000_reset(struct e1000_adapter *adapter)
                                VLAN_TAG_SIZE;
                 min_tx_space = min_rx_space;
                 min_tx_space *= 2;
-                E1000_ROUNDUP(min_tx_space, 1024);
+                min_tx_space = ALIGN(min_tx_space, 1024);
                 min_tx_space >>= 10;
-                E1000_ROUNDUP(min_rx_space, 1024);
+                min_rx_space = ALIGN(min_rx_space, 1024);
                 min_rx_space >>= 10;
 
                 /* If current Tx allocation is less than the min Tx FIFO size,
@@ -1354,31 +1354,27 @@ e1000_sw_init(struct e1000_adapter *adapter)
 static int __devinit
 e1000_alloc_queues(struct e1000_adapter *adapter)
 {
-        int size;
-
-        size = sizeof(struct e1000_tx_ring) * adapter->num_tx_queues;
-        adapter->tx_ring = kmalloc(size, GFP_KERNEL);
+        adapter->tx_ring = kcalloc(adapter->num_tx_queues,
+                                   sizeof(struct e1000_tx_ring), GFP_KERNEL);
         if (!adapter->tx_ring)
                 return -ENOMEM;
-        memset(adapter->tx_ring, 0, size);
 
-        size = sizeof(struct e1000_rx_ring) * adapter->num_rx_queues;
-        adapter->rx_ring = kmalloc(size, GFP_KERNEL);
+        adapter->rx_ring = kcalloc(adapter->num_rx_queues,
+                                   sizeof(struct e1000_rx_ring), GFP_KERNEL);
         if (!adapter->rx_ring) {
                 kfree(adapter->tx_ring);
                 return -ENOMEM;
         }
-        memset(adapter->rx_ring, 0, size);
 
 #ifdef CONFIG_E1000_NAPI
-        size = sizeof(struct net_device) * adapter->num_rx_queues;
-        adapter->polling_netdev = kmalloc(size, GFP_KERNEL);
+        adapter->polling_netdev = kcalloc(adapter->num_rx_queues,
+                                          sizeof(struct net_device),
+                                          GFP_KERNEL);
         if (!adapter->polling_netdev) {
                 kfree(adapter->tx_ring);
                 kfree(adapter->rx_ring);
                 return -ENOMEM;
         }
-        memset(adapter->polling_netdev, 0, size);
 #endif
 
         return E1000_SUCCESS;
@@ -1560,7 +1556,7 @@ e1000_setup_tx_resources(struct e1000_adapter *adapter,
         /* round up to nearest 4K */
 
         txdr->size = txdr->count * sizeof(struct e1000_tx_desc);
-        E1000_ROUNDUP(txdr->size, 4096);
+        txdr->size = ALIGN(txdr->size, 4096);
 
         txdr->desc = pci_alloc_consistent(pdev, txdr->size, &txdr->dma);
         if (!txdr->desc) {
@@ -1774,18 +1770,18 @@ e1000_setup_rx_resources(struct e1000_adapter *adapter,
         }
         memset(rxdr->buffer_info, 0, size);
 
-        size = sizeof(struct e1000_ps_page) * rxdr->count;
-        rxdr->ps_page = kmalloc(size, GFP_KERNEL);
+        rxdr->ps_page = kcalloc(rxdr->count, sizeof(struct e1000_ps_page),
+                                GFP_KERNEL);
         if (!rxdr->ps_page) {
                 vfree(rxdr->buffer_info);
                 DPRINTK(PROBE, ERR,
                 "Unable to allocate memory for the receive descriptor ring\n");
                 return -ENOMEM;
         }
-        memset(rxdr->ps_page, 0, size);
 
-        size = sizeof(struct e1000_ps_page_dma) * rxdr->count;
-        rxdr->ps_page_dma = kmalloc(size, GFP_KERNEL);
+        rxdr->ps_page_dma = kcalloc(rxdr->count,
+                                    sizeof(struct e1000_ps_page_dma),
+                                    GFP_KERNEL);
         if (!rxdr->ps_page_dma) {
                 vfree(rxdr->buffer_info);
                 kfree(rxdr->ps_page);
@@ -1793,7 +1789,6 @@ e1000_setup_rx_resources(struct e1000_adapter *adapter,
                 "Unable to allocate memory for the receive descriptor ring\n");
                 return -ENOMEM;
         }
-        memset(rxdr->ps_page_dma, 0, size);
 
         if (adapter->hw.mac_type <= e1000_82547_rev_2)
                 desc_len = sizeof(struct e1000_rx_desc);
@@ -1803,7 +1798,7 @@ e1000_setup_rx_resources(struct e1000_adapter *adapter,
         /* Round up to nearest 4K */
 
         rxdr->size = rxdr->count * desc_len;
-        E1000_ROUNDUP(rxdr->size, 4096);
+        rxdr->size = ALIGN(rxdr->size, 4096);
 
         rxdr->desc = pci_alloc_consistent(pdev, rxdr->size, &rxdr->dma);
 
@@ -2667,7 +2662,7 @@ e1000_watchdog(unsigned long data)
 
                         netif_carrier_on(netdev);
                         netif_wake_queue(netdev);
-                        mod_timer(&adapter->phy_info_timer, 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 */
@@ -2684,7 +2679,7 @@ e1000_watchdog(unsigned long data)
                         DPRINTK(LINK, INFO, "NIC Link is Down\n");
                         netif_carrier_off(netdev);
                         netif_stop_queue(netdev);
-                        mod_timer(&adapter->phy_info_timer, jiffies + 2 * HZ);
+                        mod_timer(&adapter->phy_info_timer, round_jiffies(jiffies + 2 * HZ));
 
                         /* 80003ES2LAN workaround--
                          * For packet buffer work-around on link down event;
@@ -2736,7 +2731,7 @@ e1000_watchdog(unsigned long data)
                 e1000_rar_set(&adapter->hw, adapter->hw.mac_addr, 0);
 
         /* Reset the timer */
-        mod_timer(&adapter->watchdog_timer, jiffies + 2 * HZ);
+        mod_timer(&adapter->watchdog_timer, round_jiffies(jiffies + 2 * HZ));
 }
 
 enum latency_range {
@@ -3175,7 +3170,7 @@ e1000_82547_fifo_workaround(struct e1000_adapter *adapter, struct sk_buff *skb)
         uint32_t fifo_space = adapter->tx_fifo_size - adapter->tx_fifo_head;
         uint32_t skb_fifo_len = skb->len + E1000_FIFO_HDR;
 
-        E1000_ROUNDUP(skb_fifo_len, E1000_FIFO_HDR);
+        skb_fifo_len = ALIGN(skb_fifo_len, E1000_FIFO_HDR);
 
         if (adapter->link_duplex != HALF_DUPLEX)
                 goto no_fifo_stall_required;