serial: omap: drop DMA support
authorFelipe Balbi <balbi@ti.com>
Thu, 6 Sep 2012 12:45:21 +0000 (15:45 +0300)
committerGreg Kroah-Hartman <gregkh@linuxfoundation.org>
Thu, 6 Sep 2012 16:17:00 +0000 (09:17 -0700)
The current support is known to be broken and
a later patch will come re-adding it using
dma engine API.

Tested-by: Shubhrajyoti D <shubhrajyoti@ti.com>
Acked-by: Santosh Shilimkar <santosh.shilimkar@ti.com>
Signed-off-by: Felipe Balbi <balbi@ti.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
drivers/tty/serial/omap-serial.c

index 5af5d228f7d62b12557bf5764f8d161e49a80342..dd3971fe899f2aba71c5abb3c51754b7e64eda22 100644 (file)
@@ -33,7 +33,6 @@
 #include <linux/tty.h>
 #include <linux/tty_flip.h>
 #include <linux/io.h>
-#include <linux/dma-mapping.h>
 #include <linux/clk.h>
 #include <linux/serial_core.h>
 #include <linux/irq.h>
@@ -41,7 +40,6 @@
 #include <linux/of.h>
 #include <linux/gpio.h>
 
-#include <plat/dma.h>
 #include <plat/dmtimer.h>
 #include <plat/omap-serial.h>
 
@@ -75,9 +73,6 @@
 static struct uart_omap_port *ui[OMAP_MAX_HSUART_PORTS];
 
 /* Forward declaration of functions */
-static void uart_tx_dma_callback(int lch, u16 ch_status, void *data);
-static void serial_omap_rxdma_poll(unsigned long uart_no);
-static int serial_omap_start_rxdma(struct uart_omap_port *up);
 static void serial_omap_mdr1_errataset(struct uart_omap_port *up, u8 mdr1);
 
 static struct workqueue_struct *serial_omap_uart_wq;
@@ -161,19 +156,6 @@ serial_omap_get_divisor(struct uart_port *port, unsigned int baud)
        return port->uartclk/(baud * divisor);
 }
 
-static void serial_omap_stop_rxdma(struct uart_omap_port *up)
-{
-       if (up->uart_dma.rx_dma_used) {
-               del_timer(&up->uart_dma.rx_timer);
-               omap_stop_dma(up->uart_dma.rx_dma_channel);
-               omap_free_dma(up->uart_dma.rx_dma_channel);
-               up->uart_dma.rx_dma_channel = OMAP_UART_DMA_CH_FREE;
-               up->uart_dma.rx_dma_used = false;
-               pm_runtime_mark_last_busy(up->dev);
-               pm_runtime_put_autosuspend(up->dev);
-       }
-}
-
 static void serial_omap_enable_ms(struct uart_port *port)
 {
        struct uart_omap_port *up = to_uart_omap_port(port);
@@ -189,22 +171,6 @@ static void serial_omap_enable_ms(struct uart_port *port)
 static void serial_omap_stop_tx(struct uart_port *port)
 {
        struct uart_omap_port *up = to_uart_omap_port(port);
-       struct omap_uart_port_info *pdata = up->dev->platform_data;
-
-       if (up->use_dma &&
-               up->uart_dma.tx_dma_channel != OMAP_UART_DMA_CH_FREE) {
-               /*
-                * Check if dma is still active. If yes do nothing,
-                * return. Else stop dma
-                */
-               if (omap_get_dma_active_status(up->uart_dma.tx_dma_channel))
-                       return;
-               omap_stop_dma(up->uart_dma.tx_dma_channel);
-               omap_free_dma(up->uart_dma.tx_dma_channel);
-               up->uart_dma.tx_dma_channel = OMAP_UART_DMA_CH_FREE;
-               pm_runtime_mark_last_busy(up->dev);
-               pm_runtime_put_autosuspend(up->dev);
-       }
 
        pm_runtime_get_sync(up->dev);
        if (up->ier & UART_IER_THRI) {
@@ -212,8 +178,7 @@ static void serial_omap_stop_tx(struct uart_port *port)
                serial_out(up, UART_IER, up->ier);
        }
 
-       if (!up->use_dma && pdata)
-               serial_omap_set_forceidle(up);
+       serial_omap_set_forceidle(up);
 
        pm_runtime_mark_last_busy(up->dev);
        pm_runtime_put_autosuspend(up->dev);
@@ -224,8 +189,6 @@ static void serial_omap_stop_rx(struct uart_port *port)
        struct uart_omap_port *up = to_uart_omap_port(port);
 
        pm_runtime_get_sync(up->dev);
-       if (up->use_dma)
-               serial_omap_stop_rxdma(up);
        up->ier &= ~UART_IER_RLSI;
        up->port.read_status_mask &= ~UART_LSR_DR;
        serial_out(up, UART_IER, up->ier);
@@ -343,67 +306,12 @@ static inline void serial_omap_enable_ier_thri(struct uart_omap_port *up)
 static void serial_omap_start_tx(struct uart_port *port)
 {
        struct uart_omap_port *up = to_uart_omap_port(port);
-       struct circ_buf *xmit;
-       unsigned int start;
-       int ret = 0;
-
-       if (!up->use_dma) {
-               pm_runtime_get_sync(up->dev);
-               serial_omap_enable_ier_thri(up);
-               serial_omap_set_noidle(up);
-               pm_runtime_mark_last_busy(up->dev);
-               pm_runtime_put_autosuspend(up->dev);
-               return;
-       }
-
-       if (up->uart_dma.tx_dma_used)
-               return;
-
-       xmit = &up->port.state->xmit;
-
-       if (up->uart_dma.tx_dma_channel == OMAP_UART_DMA_CH_FREE) {
-               pm_runtime_get_sync(up->dev);
-               ret = omap_request_dma(up->uart_dma.uart_dma_tx,
-                               "UART Tx DMA",
-                               (void *)uart_tx_dma_callback, up,
-                               &(up->uart_dma.tx_dma_channel));
 
-               if (ret < 0) {
-                       serial_omap_enable_ier_thri(up);
-                       return;
-               }
-       }
-       spin_lock(&(up->uart_dma.tx_lock));
-       up->uart_dma.tx_dma_used = true;
-       spin_unlock(&(up->uart_dma.tx_lock));
-
-       start = up->uart_dma.tx_buf_dma_phys +
-                               (xmit->tail & (UART_XMIT_SIZE - 1));
-
-       up->uart_dma.tx_buf_size = uart_circ_chars_pending(xmit);
-       /*
-        * It is a circular buffer. See if the buffer has wounded back.
-        * If yes it will have to be transferred in two separate dma
-        * transfers
-        */
-       if (start + up->uart_dma.tx_buf_size >=
-                       up->uart_dma.tx_buf_dma_phys + UART_XMIT_SIZE)
-               up->uart_dma.tx_buf_size =
-                       (up->uart_dma.tx_buf_dma_phys +
-                       UART_XMIT_SIZE) - start;
-
-       omap_set_dma_dest_params(up->uart_dma.tx_dma_channel, 0,
-                               OMAP_DMA_AMODE_CONSTANT,
-                               up->uart_dma.uart_base, 0, 0);
-       omap_set_dma_src_params(up->uart_dma.tx_dma_channel, 0,
-                               OMAP_DMA_AMODE_POST_INC, start, 0, 0);
-       omap_set_dma_transfer_params(up->uart_dma.tx_dma_channel,
-                               OMAP_DMA_DATA_TYPE_S8,
-                               up->uart_dma.tx_buf_size, 1,
-                               OMAP_DMA_SYNC_ELEMENT,
-                               up->uart_dma.uart_dma_tx, 0);
-       /* FIXME: Cache maintenance needed here? */
-       omap_start_dma(up->uart_dma.tx_dma_channel);
+       pm_runtime_get_sync(up->dev);
+       serial_omap_enable_ier_thri(up);
+       serial_omap_set_noidle(up);
+       pm_runtime_mark_last_busy(up->dev);
+       pm_runtime_put_autosuspend(up->dev);
 }
 
 static unsigned int check_modem_status(struct uart_omap_port *up)
@@ -456,16 +364,8 @@ static inline irqreturn_t serial_omap_irq(int irq, void *dev_id)
        spin_lock_irqsave(&up->port.lock, flags);
        lsr = serial_in(up, UART_LSR);
        if (iir & UART_IIR_RLSI) {
-               if (!up->use_dma) {
-                       if (lsr & UART_LSR_DR)
-                               receive_chars(up, &lsr);
-               } else {
-                       up->ier &= ~(UART_IER_RDI | UART_IER_RLSI);
-                       serial_out(up, UART_IER, up->ier);
-                       if ((serial_omap_start_rxdma(up) != 0) &&
-                                       (lsr & UART_LSR_DR))
-                               receive_chars(up, &lsr);
-               }
+               if (lsr & UART_LSR_DR)
+                       receive_chars(up, &lsr);
        }
 
        check_modem_status(up);
@@ -616,20 +516,6 @@ static int serial_omap_startup(struct uart_port *port)
        spin_unlock_irqrestore(&up->port.lock, flags);
 
        up->msr_saved_flags = 0;
-       if (up->use_dma) {
-               free_page((unsigned long)up->port.state->xmit.buf);
-               up->port.state->xmit.buf = dma_alloc_coherent(NULL,
-                       UART_XMIT_SIZE,
-                       (dma_addr_t *)&(up->uart_dma.tx_buf_dma_phys),
-                       0);
-               init_timer(&(up->uart_dma.rx_timer));
-               up->uart_dma.rx_timer.function = serial_omap_rxdma_poll;
-               up->uart_dma.rx_timer.data = up->port.line;
-               /* Currently the buffer size is 4KB. Can increase it */
-               up->uart_dma.rx_buf = dma_alloc_coherent(NULL,
-                       up->uart_dma.rx_buf_size,
-                       (dma_addr_t *)&(up->uart_dma.rx_buf_dma_phys), 0);
-       }
        /*
         * Finally, enable interrupts. Note: Modem status interrupts
         * are set via set_termios(), which will be occurring imminently
@@ -677,17 +563,6 @@ static void serial_omap_shutdown(struct uart_port *port)
         */
        if (serial_in(up, UART_LSR) & UART_LSR_DR)
                (void) serial_in(up, UART_RX);
-       if (up->use_dma) {
-               dma_free_coherent(up->port.dev,
-                       UART_XMIT_SIZE, up->port.state->xmit.buf,
-                       up->uart_dma.tx_buf_dma_phys);
-               up->port.state->xmit.buf = NULL;
-               serial_omap_stop_rx(port);
-               dma_free_coherent(up->port.dev,
-                       up->uart_dma.rx_buf_size, up->uart_dma.rx_buf,
-                       up->uart_dma.rx_buf_dma_phys);
-               up->uart_dma.rx_buf = NULL;
-       }
 
        pm_runtime_put(up->dev);
        free_irq(up->port.irq, up);
@@ -814,8 +689,6 @@ serial_omap_set_termios(struct uart_port *port, struct ktermios *termios,
 
        up->fcr = UART_FCR_R_TRIG_01 | UART_FCR_T_TRIG_01 |
                        UART_FCR_ENABLE_FIFO;
-       if (up->use_dma)
-               up->fcr |= UART_FCR_DMA_SELECT;
 
        /*
         * Ok, we're now changing the port state. Do it with
@@ -891,14 +764,9 @@ serial_omap_set_termios(struct uart_port *port, struct ktermios *termios,
 
        up->scr |= OMAP_UART_SCR_RX_TRIG_GRANU1_MASK;
 
-       if (up->use_dma) {
-               serial_out(up, UART_TI752_TLR, 0);
-               up->scr |= UART_FCR_TRIGGER_4;
-       } else {
-               /* Set receive FIFO threshold to 1 byte */
-               up->fcr &= ~OMAP_UART_FCR_RX_FIFO_TRIG_MASK;
-               up->fcr |= (0x1 << OMAP_UART_FCR_RX_FIFO_TRIG_SHIFT);
-       }
+       /* Set receive FIFO threshold to 1 byte */
+       up->fcr &= ~OMAP_UART_FCR_RX_FIFO_TRIG_MASK;
+       up->fcr |= (0x1 << OMAP_UART_FCR_RX_FIFO_TRIG_SHIFT);
 
        serial_out(up, UART_FCR, up->fcr);
        serial_out(up, UART_LCR, UART_LCR_CONF_MODE_B);
@@ -1267,149 +1135,6 @@ static int serial_omap_resume(struct device *dev)
 }
 #endif
 
-static void serial_omap_rxdma_poll(unsigned long uart_no)
-{
-       struct uart_omap_port *up = ui[uart_no];
-       unsigned int curr_dma_pos, curr_transmitted_size;
-       int ret = 0;
-
-       curr_dma_pos = omap_get_dma_dst_pos(up->uart_dma.rx_dma_channel);
-       if ((curr_dma_pos == up->uart_dma.prev_rx_dma_pos) ||
-                            (curr_dma_pos == 0)) {
-               if (jiffies_to_msecs(jiffies - up->port_activity) <
-                                               up->uart_dma.rx_timeout) {
-                       mod_timer(&up->uart_dma.rx_timer, jiffies +
-                               usecs_to_jiffies(up->uart_dma.rx_poll_rate));
-               } else {
-                       serial_omap_stop_rxdma(up);
-                       up->ier |= (UART_IER_RDI | UART_IER_RLSI);
-                       serial_out(up, UART_IER, up->ier);
-               }
-               return;
-       }
-
-       curr_transmitted_size = curr_dma_pos -
-                                       up->uart_dma.prev_rx_dma_pos;
-       up->port.icount.rx += curr_transmitted_size;
-       tty_insert_flip_string(up->port.state->port.tty,
-                       up->uart_dma.rx_buf +
-                       (up->uart_dma.prev_rx_dma_pos -
-                       up->uart_dma.rx_buf_dma_phys),
-                       curr_transmitted_size);
-       tty_flip_buffer_push(up->port.state->port.tty);
-       up->uart_dma.prev_rx_dma_pos = curr_dma_pos;
-       if (up->uart_dma.rx_buf_size +
-                       up->uart_dma.rx_buf_dma_phys == curr_dma_pos) {
-               ret = serial_omap_start_rxdma(up);
-               if (ret < 0) {
-                       serial_omap_stop_rxdma(up);
-                       up->ier |= (UART_IER_RDI | UART_IER_RLSI);
-                       serial_out(up, UART_IER, up->ier);
-               }
-       } else  {
-               mod_timer(&up->uart_dma.rx_timer, jiffies +
-                       usecs_to_jiffies(up->uart_dma.rx_poll_rate));
-       }
-       up->port_activity = jiffies;
-}
-
-static void uart_rx_dma_callback(int lch, u16 ch_status, void *data)
-{
-       return;
-}
-
-static int serial_omap_start_rxdma(struct uart_omap_port *up)
-{
-       int ret = 0;
-
-       if (up->uart_dma.rx_dma_channel == -1) {
-               pm_runtime_get_sync(up->dev);
-               ret = omap_request_dma(up->uart_dma.uart_dma_rx,
-                               "UART Rx DMA",
-                               (void *)uart_rx_dma_callback, up,
-                               &(up->uart_dma.rx_dma_channel));
-               if (ret < 0)
-                       return ret;
-
-               omap_set_dma_src_params(up->uart_dma.rx_dma_channel, 0,
-                               OMAP_DMA_AMODE_CONSTANT,
-                               up->uart_dma.uart_base, 0, 0);
-               omap_set_dma_dest_params(up->uart_dma.rx_dma_channel, 0,
-                               OMAP_DMA_AMODE_POST_INC,
-                               up->uart_dma.rx_buf_dma_phys, 0, 0);
-               omap_set_dma_transfer_params(up->uart_dma.rx_dma_channel,
-                               OMAP_DMA_DATA_TYPE_S8,
-                               up->uart_dma.rx_buf_size, 1,
-                               OMAP_DMA_SYNC_ELEMENT,
-                               up->uart_dma.uart_dma_rx, 0);
-       }
-       up->uart_dma.prev_rx_dma_pos = up->uart_dma.rx_buf_dma_phys;
-       /* FIXME: Cache maintenance needed here? */
-       omap_start_dma(up->uart_dma.rx_dma_channel);
-       mod_timer(&up->uart_dma.rx_timer, jiffies +
-                               usecs_to_jiffies(up->uart_dma.rx_poll_rate));
-       up->uart_dma.rx_dma_used = true;
-       return ret;
-}
-
-static void serial_omap_continue_tx(struct uart_omap_port *up)
-{
-       struct circ_buf *xmit = &up->port.state->xmit;
-       unsigned int start = up->uart_dma.tx_buf_dma_phys
-                       + (xmit->tail & (UART_XMIT_SIZE - 1));
-
-       if (uart_circ_empty(xmit))
-               return;
-
-       up->uart_dma.tx_buf_size = uart_circ_chars_pending(xmit);
-       /*
-        * It is a circular buffer. See if the buffer has wounded back.
-        * If yes it will have to be transferred in two separate dma
-        * transfers
-        */
-       if (start + up->uart_dma.tx_buf_size >=
-                       up->uart_dma.tx_buf_dma_phys + UART_XMIT_SIZE)
-               up->uart_dma.tx_buf_size =
-                       (up->uart_dma.tx_buf_dma_phys + UART_XMIT_SIZE) - start;
-       omap_set_dma_dest_params(up->uart_dma.tx_dma_channel, 0,
-                               OMAP_DMA_AMODE_CONSTANT,
-                               up->uart_dma.uart_base, 0, 0);
-       omap_set_dma_src_params(up->uart_dma.tx_dma_channel, 0,
-                               OMAP_DMA_AMODE_POST_INC, start, 0, 0);
-       omap_set_dma_transfer_params(up->uart_dma.tx_dma_channel,
-                               OMAP_DMA_DATA_TYPE_S8,
-                               up->uart_dma.tx_buf_size, 1,
-                               OMAP_DMA_SYNC_ELEMENT,
-                               up->uart_dma.uart_dma_tx, 0);
-       /* FIXME: Cache maintenance needed here? */
-       omap_start_dma(up->uart_dma.tx_dma_channel);
-}
-
-static void uart_tx_dma_callback(int lch, u16 ch_status, void *data)
-{
-       struct uart_omap_port *up = data;
-       struct circ_buf *xmit = &up->port.state->xmit;
-
-       xmit->tail = (xmit->tail + up->uart_dma.tx_buf_size) & \
-                       (UART_XMIT_SIZE - 1);
-       up->port.icount.tx += up->uart_dma.tx_buf_size;
-
-       if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
-               uart_write_wakeup(&up->port);
-
-       if (uart_circ_empty(xmit)) {
-               spin_lock(&(up->uart_dma.tx_lock));
-               serial_omap_stop_tx(&up->port);
-               up->uart_dma.tx_dma_used = false;
-               spin_unlock(&(up->uart_dma.tx_lock));
-       } else {
-               omap_stop_dma(up->uart_dma.tx_dma_channel);
-               serial_omap_continue_tx(up);
-       }
-       up->port_activity = jiffies;
-       return;
-}
-
 static void omap_serial_fill_features_erratas(struct uart_omap_port *up)
 {
        u32 mvr, scheme;
@@ -1479,7 +1204,7 @@ static struct omap_uart_port_info *of_get_uart_port_info(struct device *dev)
 static int serial_omap_probe(struct platform_device *pdev)
 {
        struct uart_omap_port   *up;
-       struct resource         *mem, *irq, *dma_tx, *dma_rx;
+       struct resource         *mem, *irq;
        struct omap_uart_port_info *omap_up_info = pdev->dev.platform_data;
        int ret;
 
@@ -1504,14 +1229,6 @@ static int serial_omap_probe(struct platform_device *pdev)
                return -EBUSY;
        }
 
-       dma_rx = platform_get_resource_byname(pdev, IORESOURCE_DMA, "rx");
-       if (!dma_rx)
-               return -ENXIO;
-
-       dma_tx = platform_get_resource_byname(pdev, IORESOURCE_DMA, "tx");
-       if (!dma_tx)
-               return -ENXIO;
-
        if (gpio_is_valid(omap_up_info->DTR_gpio) &&
            omap_up_info->DTR_present) {
                ret = gpio_request(omap_up_info->DTR_gpio, "omap-serial");
@@ -1574,20 +1291,6 @@ static int serial_omap_probe(struct platform_device *pdev)
                dev_warn(&pdev->dev, "No clock speed specified: using default:"
                                                "%d\n", DEFAULT_CLK_SPEED);
        }
-       up->uart_dma.uart_base = mem->start;
-
-       if (omap_up_info->dma_enabled) {
-               up->uart_dma.uart_dma_tx = dma_tx->start;
-               up->uart_dma.uart_dma_rx = dma_rx->start;
-               up->use_dma = 1;
-               up->uart_dma.rx_buf_size = omap_up_info->dma_rx_buf_size;
-               up->uart_dma.rx_timeout = omap_up_info->dma_rx_timeout;
-               up->uart_dma.rx_poll_rate = omap_up_info->dma_rx_poll_rate;
-               spin_lock_init(&(up->uart_dma.tx_lock));
-               spin_lock_init(&(up->uart_dma.rx_lock));
-               up->uart_dma.tx_dma_channel = OMAP_UART_DMA_CH_FREE;
-               up->uart_dma.rx_dma_channel = OMAP_UART_DMA_CH_FREE;
-       }
 
        up->latency = PM_QOS_CPU_DMA_LAT_DEFAULT_VALUE;
        up->calc_latency = PM_QOS_CPU_DMA_LAT_DEFAULT_VALUE;
@@ -1730,10 +1433,6 @@ static int serial_omap_runtime_suspend(struct device *dev)
                }
        }
 
-       /* Errata i291 */
-       if (up->use_dma && (up->errata & UART_ERRATA_i291_DMA_FORCEIDLE))
-               serial_omap_set_forceidle(up);
-
        up->latency = PM_QOS_CPU_DMA_LAT_DEFAULT_VALUE;
        schedule_work(&up->qos_work);
 
@@ -1751,11 +1450,6 @@ static int serial_omap_runtime_resume(struct device *dev)
                        if (up->context_loss_cnt != loss_cnt)
                                serial_omap_restore_context(up);
 
-               /* Errata i291 */
-               if ((up->errata & UART_ERRATA_i291_DMA_FORCEIDLE) &&
-                               up->use_dma)
-                       serial_omap_set_noidle(up);
-
                up->latency = up->calc_latency;
                schedule_work(&up->qos_work);
        }