#define mfd_readl(obj, offset)         readl(obj->reg + offset)
 #define mfd_writel(obj, offset, val)   writel(val, obj->reg + offset)
 
-#define HSU_DMA_TIMEOUT_CHECK_FREQ     (HZ/10)
-
 struct hsu_dma_buffer {
        u8              *buf;
        dma_addr_t      dma_addr;
        enum dma_data_direction dirt;
        struct uart_hsu_port    *uport;
        void __iomem            *reg;
-       struct timer_list       rx_timer; /* only needed by RX channel */
 };
 
 struct uart_hsu_port {
                                         | (0x1 << 24)  /* timeout bit, see HSU Errata 1 */
                                         );
        chan_writel(rxc, HSU_CH_CR, 0x3);
-
-       mod_timer(&rxc->rx_timer, jiffies + HSU_DMA_TIMEOUT_CHECK_FREQ);
 }
 
 /* Protected by spin_lock_irqsave(port->lock) */
                chan_writel(chan, HSU_CH_CR, 0x3);
                return;
        }
-       del_timer(&chan->rx_timer);
 
        dma_sync_single_for_cpu(port->dev, dbuf->dma_addr,
                        dbuf->dma_size, DMA_FROM_DEVICE);
        tty_flip_buffer_push(tty);
 
        chan_writel(chan, HSU_CH_CR, 0x3);
-       chan->rx_timer.expires = jiffies + HSU_DMA_TIMEOUT_CHECK_FREQ;
-       add_timer(&chan->rx_timer);
 
 }
 
                container_of(port, struct uart_hsu_port, port);
        unsigned long flags;
 
-       del_timer_sync(&up->rxc->rx_timer);
-
        /* Disable interrupts from this port */
        up->ier = 0;
        serial_out(up, UART_IER, 0);
        return ret;
 }
 
-static void hsu_dma_rx_timeout(unsigned long data)
-{
-       struct hsu_dma_chan *chan = (void *)data;
-       struct uart_hsu_port *up = chan->uport;
-       struct hsu_dma_buffer *dbuf = &up->rxbuf;
-       int count = 0;
-       unsigned long flags;
-
-       spin_lock_irqsave(&up->port.lock, flags);
-
-       count = chan_readl(chan, HSU_CH_D0SAR) - dbuf->dma_addr;
-
-       if (!count) {
-               mod_timer(&chan->rx_timer, jiffies + HSU_DMA_TIMEOUT_CHECK_FREQ);
-               goto exit;
-       }
-
-       hsu_dma_rx(up, 0);
-exit:
-       spin_unlock_irqrestore(&up->port.lock, flags);
-}
-
 static void hsu_global_init(void)
 {
        struct hsu_port *hsu;
                dchan->reg = hsu->reg + HSU_DMA_CHANS_REG_OFFSET +
                                i * HSU_DMA_CHANS_REG_LENGTH;
 
-               /* Work around for RX */
-               if (dchan->dirt == DMA_FROM_DEVICE) {
-                       init_timer(&dchan->rx_timer);
-                       dchan->rx_timer.function = hsu_dma_rx_timeout;
-                       dchan->rx_timer.data = (unsigned long)dchan;
-               }
                dchan++;
        }