/* Number of packet split data buffers (not including the header buffer) */
 #define PS_PAGE_BUFFERS MAX_PS_BUFFERS-1
 
-/* only works for sizes that are powers of 2 */
-#define E1000_ROUNDUP(i, size) ((i) = (((i) + (size) - 1) & ~((size) - 1)))
-
 /* wrapper around a pointer to a socket buffer,
  * so a DMA handle can be stored along with the buffer */
 struct e1000_buffer {
 
        rxdr->count = max(ring->rx_pending,(uint32_t)E1000_MIN_RXD);
        rxdr->count = min(rxdr->count,(uint32_t)(mac_type < e1000_82544 ?
                E1000_MAX_RXD : E1000_MAX_82544_RXD));
-       E1000_ROUNDUP(rxdr->count, REQ_RX_DESCRIPTOR_MULTIPLE);
+       rxdr->count = ALIGN(rxdr->count, REQ_RX_DESCRIPTOR_MULTIPLE);
 
        txdr->count = max(ring->tx_pending,(uint32_t)E1000_MIN_TXD);
        txdr->count = min(txdr->count,(uint32_t)(mac_type < e1000_82544 ?
                E1000_MAX_TXD : E1000_MAX_82544_TXD));
-       E1000_ROUNDUP(txdr->count, REQ_TX_DESCRIPTOR_MULTIPLE);
+       txdr->count = ALIGN(txdr->count, REQ_TX_DESCRIPTOR_MULTIPLE);
 
        for (i = 0; i < adapter->num_tx_queues; i++)
                txdr[i].count = txdr->count;
        }
 
        txdr->size = txdr->count * sizeof(struct e1000_tx_desc);
-       E1000_ROUNDUP(txdr->size, 4096);
+       txdr->size = ALIGN(txdr->size, 4096);
        if (!(txdr->desc = pci_alloc_consistent(pdev, txdr->size,
                                                &txdr->dma))) {
                ret_val = 2;
 
                               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,
        /* 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) {
        /* 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);
 
        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;
 
                if (num_TxDescriptors > bd) {
                        tx_ring->count = TxDescriptors[bd];
                        e1000_validate_option(&tx_ring->count, &opt, adapter);
-                       E1000_ROUNDUP(tx_ring->count,
+                       tx_ring->count = ALIGN(tx_ring->count,
                                                REQ_TX_DESCRIPTOR_MULTIPLE);
                } else {
                        tx_ring->count = opt.def;
                if (num_RxDescriptors > bd) {
                        rx_ring->count = RxDescriptors[bd];
                        e1000_validate_option(&rx_ring->count, &opt, adapter);
-                       E1000_ROUNDUP(rx_ring->count,
+                       rx_ring->count = ALIGN(rx_ring->count,
                                                REQ_RX_DESCRIPTOR_MULTIPLE);
                } else {
                        rx_ring->count = opt.def;