serial: omap: drop DMA support (49457430) · Commits · e / devices / android_kernel_sony_msm8998

drivers/tty/serial/omap-serial.c

+12 −318

Original line number	Diff line number	Diff line
		@@ -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,7 +178,6 @@ 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);

		pm_runtime_mark_last_busy(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);
		}

		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);
		}
		}

		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);
		}

		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);
		}