XGMAC_DMA_IOWRITE(channel, DMA_CH_TDTR_LO,
                          lower_32_bits(rdata->rdesc_dma));
 
-       /* Start the Tx coalescing timer */
+       /* Start the Tx timer */
        if (pdata->tx_usecs && !channel->tx_timer_active) {
                channel->tx_timer_active = 1;
-               hrtimer_start(&channel->tx_timer,
-                             ktime_set(0, pdata->tx_usecs * NSEC_PER_USEC),
-                             HRTIMER_MODE_REL);
+               mod_timer(&channel->tx_timer,
+                         jiffies + usecs_to_jiffies(pdata->tx_usecs));
        }
 
        ring->tx.xmit_more = 0;
 
        return IRQ_HANDLED;
 }
 
-static enum hrtimer_restart xgbe_tx_timer(struct hrtimer *timer)
+static void xgbe_tx_timer(unsigned long data)
 {
-       struct xgbe_channel *channel = container_of(timer,
-                                                   struct xgbe_channel,
-                                                   tx_timer);
+       struct xgbe_channel *channel = (struct xgbe_channel *)data;
        struct xgbe_prv_data *pdata = channel->pdata;
        struct napi_struct *napi;
 
        channel->tx_timer_active = 0;
 
        DBGPR("<--xgbe_tx_timer\n");
-
-       return HRTIMER_NORESTART;
 }
 
 static void xgbe_init_tx_timers(struct xgbe_prv_data *pdata)
                        break;
 
                DBGPR("  %s adding tx timer\n", channel->name);
-               hrtimer_init(&channel->tx_timer, CLOCK_MONOTONIC,
-                            HRTIMER_MODE_REL);
-               channel->tx_timer.function = xgbe_tx_timer;
+               setup_timer(&channel->tx_timer, xgbe_tx_timer,
+                           (unsigned long)channel);
        }
 
        DBGPR("<--xgbe_init_tx_timers\n");
                        break;
 
                DBGPR("  %s deleting tx timer\n", channel->name);
-               channel->tx_timer_active = 0;
-               hrtimer_cancel(&channel->tx_timer);
+               del_timer_sync(&channel->tx_timer);
        }
 
        DBGPR("<--xgbe_stop_tx_timers\n");
 
        ec->rx_coalesce_usecs = hw_if->riwt_to_usec(pdata, riwt);
        ec->rx_max_coalesced_frames = pdata->rx_frames;
 
-       ec->tx_coalesce_usecs = pdata->tx_usecs;
        ec->tx_max_coalesced_frames = pdata->tx_frames;
 
        DBGPR("<--xgbe_get_coalesce\n");
        struct xgbe_prv_data *pdata = netdev_priv(netdev);
        struct xgbe_hw_if *hw_if = &pdata->hw_if;
        unsigned int rx_frames, rx_riwt, rx_usecs;
-       unsigned int tx_frames, tx_usecs;
+       unsigned int tx_frames;
 
        DBGPR("-->xgbe_set_coalesce\n");
 
        /* Check for not supported parameters  */
        if ((ec->rx_coalesce_usecs_irq) ||
            (ec->rx_max_coalesced_frames_irq) ||
+           (ec->tx_coalesce_usecs) ||
            (ec->tx_coalesce_usecs_irq) ||
            (ec->tx_max_coalesced_frames_irq) ||
            (ec->stats_block_coalesce_usecs) ||
                return -EINVAL;
        }
 
-       tx_usecs = ec->tx_coalesce_usecs;
        tx_frames = ec->tx_max_coalesced_frames;
 
        /* Check the bounds of values for Tx */
        pdata->rx_frames = rx_frames;
        hw_if->config_rx_coalesce(pdata);
 
-       pdata->tx_usecs = tx_usecs;
        pdata->tx_frames = tx_frames;
        hw_if->config_tx_coalesce(pdata);
 
 
         ((_idx) & ((_ring)->rdesc_count - 1)))
 
 /* Default coalescing parameters */
-#define XGMAC_INIT_DMA_TX_USECS                50
+#define XGMAC_INIT_DMA_TX_USECS                1000
 #define XGMAC_INIT_DMA_TX_FRAMES       25
 
 #define XGMAC_MAX_DMA_RIWT             0xff
        unsigned int saved_ier;
 
        unsigned int tx_timer_active;
-       struct hrtimer tx_timer;
+       struct timer_list tx_timer;
 
        struct xgbe_ring *tx_ring;
        struct xgbe_ring *rx_ring;