#define S3C24XX_TX_DMA                 2
 #define S3C24XX_RX_PIO                 1
 #define S3C24XX_RX_DMA                 2
-/* macros to change one thing to another */
-
-#define tx_enabled(port) ((port)->unused[0])
-#define rx_enabled(port) ((port)->unused[1])
 
 /* flag to ignore all characters coming in */
 #define RXSTAT_DUMMY_READ (0x10000000)
 struct s3c24xx_uart_port {
        unsigned char                   rx_claimed;
        unsigned char                   tx_claimed;
+       unsigned char                   rx_enabled;
+       unsigned char                   tx_enabled;
        unsigned int                    pm_level;
        unsigned long                   baudclk_rate;
        unsigned int                    min_dma_size;
 
 static void s3c24xx_serial_rx_enable(struct uart_port *port)
 {
+       struct s3c24xx_uart_port *ourport = to_ourport(port);
        unsigned long flags;
        unsigned int ucon, ufcon;
        int count = 10000;
        ucon |= S3C2410_UCON_RXIRQMODE;
        wr_regl(port, S3C2410_UCON, ucon);
 
-       rx_enabled(port) = 1;
+       ourport->rx_enabled = 1;
        spin_unlock_irqrestore(&port->lock, flags);
 }
 
 static void s3c24xx_serial_rx_disable(struct uart_port *port)
 {
+       struct s3c24xx_uart_port *ourport = to_ourport(port);
        unsigned long flags;
        unsigned int ucon;
 
        ucon &= ~S3C2410_UCON_RXIRQMODE;
        wr_regl(port, S3C2410_UCON, ucon);
 
-       rx_enabled(port) = 0;
+       ourport->rx_enabled = 0;
        spin_unlock_irqrestore(&port->lock, flags);
 }
 
        struct dma_tx_state state;
        int count;
 
-       if (!tx_enabled(port))
+       if (!ourport->tx_enabled)
                return;
 
        if (s3c24xx_serial_has_interrupt_mask(port))
                port->icount.tx += count;
        }
 
-       tx_enabled(port) = 0;
+       ourport->tx_enabled = 0;
        ourport->tx_in_progress = 0;
 
        if (port->flags & UPF_CONS_FLOW)
        struct s3c24xx_uart_port *ourport = to_ourport(port);
        struct circ_buf *xmit = &port->state->xmit;
 
-       if (!tx_enabled(port)) {
+       if (!ourport->tx_enabled) {
                if (port->flags & UPF_CONS_FLOW)
                        s3c24xx_serial_rx_disable(port);
 
-               tx_enabled(port) = 1;
+               ourport->tx_enabled = 1;
                if (!ourport->dma || !ourport->dma->tx_chan)
                        s3c24xx_serial_start_tx_pio(ourport);
        }
        enum dma_status dma_status;
        unsigned int received;
 
-       if (rx_enabled(port)) {
+       if (ourport->rx_enabled) {
                dev_dbg(port->dev, "stopping rx\n");
                if (s3c24xx_serial_has_interrupt_mask(port))
                        s3c24xx_set_bit(port, S3C64XX_UINTM_RXD,
                                        S3C64XX_UINTM);
                else
                        disable_irq_nosync(ourport->rx_irq);
-               rx_enabled(port) = 0;
+               ourport->rx_enabled = 0;
        }
        if (dma && dma->rx_chan) {
                dmaengine_pause(dma->tx_chan);
                if (port->flags & UPF_CONS_FLOW) {
                        int txe = s3c24xx_serial_txempty_nofifo(port);
 
-                       if (rx_enabled(port)) {
+                       if (ourport->rx_enabled) {
                                if (!txe) {
-                                       rx_enabled(port) = 0;
+                                       ourport->rx_enabled = 0;
                                        continue;
                                }
                        } else {
                                        ufcon = rd_regl(port, S3C2410_UFCON);
                                        ufcon |= S3C2410_UFCON_RESETRX;
                                        wr_regl(port, S3C2410_UFCON, ufcon);
-                                       rx_enabled(port) = 1;
+                                       ourport->rx_enabled = 1;
                                        return;
                                }
                                continue;
        if (ourport->tx_claimed) {
                if (!s3c24xx_serial_has_interrupt_mask(port))
                        free_irq(ourport->tx_irq, ourport);
-               tx_enabled(port) = 0;
+               ourport->tx_enabled = 0;
                ourport->tx_claimed = 0;
                ourport->tx_mode = 0;
        }
                if (!s3c24xx_serial_has_interrupt_mask(port))
                        free_irq(ourport->rx_irq, ourport);
                ourport->rx_claimed = 0;
-               rx_enabled(port) = 0;
+               ourport->rx_enabled = 0;
        }
 
        /* Clear pending interrupts and mask all interrupts */
        struct s3c24xx_uart_port *ourport = to_ourport(port);
        int ret;
 
-       rx_enabled(port) = 1;
+       ourport->rx_enabled = 1;
 
        ret = request_irq(ourport->rx_irq, s3c24xx_serial_rx_chars, 0,
                          s3c24xx_serial_portname(port), ourport);
 
        dev_dbg(port->dev, "requesting tx irq...\n");
 
-       tx_enabled(port) = 1;
+       ourport->tx_enabled = 1;
 
        ret = request_irq(ourport->tx_irq, s3c24xx_serial_tx_chars, 0,
                          s3c24xx_serial_portname(port), ourport);
        }
 
        /* For compatibility with s3c24xx Soc's */
-       rx_enabled(port) = 1;
+       ourport->rx_enabled = 1;
        ourport->rx_claimed = 1;
-       tx_enabled(port) = 0;
+       ourport->tx_enabled = 0;
        ourport->tx_claimed = 1;
 
        spin_lock_irqsave(&port->lock, flags);
                if (s3c24xx_serial_has_interrupt_mask(port)) {
                        unsigned int uintm = 0xf;
 
-                       if (tx_enabled(port))
+                       if (ourport->tx_enabled)
                                uintm &= ~S3C64XX_UINTM_TXD_MSK;
-                       if (rx_enabled(port))
+                       if (ourport->rx_enabled)
                                uintm &= ~S3C64XX_UINTM_RXD_MSK;
                        clk_prepare_enable(ourport->clk);
                        if (!IS_ERR(ourport->baudclk))