serial: 8250: Add support for dmaengine (9ee4b83e) · Commits · e / devices / android_kernel_xiaomi_markw

drivers/tty/serial/8250/8250.c

+28 −3

Original line number	Original line	Diff line number	Diff line
	@@ -1269,7 +1269,9 @@ static void serial8250_start_tx(struct uart_port *port)
	struct uart_8250_port *up =		struct uart_8250_port *up =
	container_of(port, struct uart_8250_port, port);		container_of(port, struct uart_8250_port, port);

	if (!(up->ier & UART_IER_THRI)) {		if (up->dma && !serial8250_tx_dma(up)) {
			return;
			} else if (!(up->ier & UART_IER_THRI)) {
	up->ier \|= UART_IER_THRI;		up->ier \|= UART_IER_THRI;
	serial_port_out(port, UART_IER, up->ier);		serial_port_out(port, UART_IER, up->ier);

	@@ -1467,6 +1469,7 @@ int serial8250_handle_irq(struct uart_port *port, unsigned int iir)
	unsigned long flags;		unsigned long flags;
	struct uart_8250_port *up =		struct uart_8250_port *up =
	container_of(port, struct uart_8250_port, port);		container_of(port, struct uart_8250_port, port);
			int dma_err = 0;

	if (iir & UART_IIR_NO_INT)		if (iir & UART_IIR_NO_INT)
	return 0;		return 0;
	@@ -1477,8 +1480,13 @@ int serial8250_handle_irq(struct uart_port *port, unsigned int iir)

	DEBUG_INTR("status = %x...", status);		DEBUG_INTR("status = %x...", status);

	if (status & (UART_LSR_DR \| UART_LSR_BI))		if (status & (UART_LSR_DR \| UART_LSR_BI)) {
			if (up->dma)
			dma_err = serial8250_rx_dma(up, iir);

			if (!up->dma \|\| dma_err)
	status = serial8250_rx_chars(up, status);		status = serial8250_rx_chars(up, status);
			}
	serial8250_modem_status(up);		serial8250_modem_status(up);
	if (status & UART_LSR_THRE)		if (status & UART_LSR_THRE)
	serial8250_tx_chars(up);		serial8250_tx_chars(up);
	@@ -2120,6 +2128,18 @@ dont_test_tx_en:
	up->lsr_saved_flags = 0;		up->lsr_saved_flags = 0;
	up->msr_saved_flags = 0;		up->msr_saved_flags = 0;

			/*
			* Request DMA channels for both RX and TX.
			*/
			if (up->dma) {
			retval = serial8250_request_dma(up);
			if (retval) {
			pr_warn_ratelimited("ttyS%d - failed to request DMA\n",
			serial_index(port));
			up->dma = NULL;
			}
			}

	/*		/*
	* Finally, enable interrupts. Note: Modem status interrupts		* Finally, enable interrupts. Note: Modem status interrupts
	* are set via set_termios(), which will be occurring imminently		* are set via set_termios(), which will be occurring imminently
	@@ -2153,6 +2173,9 @@ static void serial8250_shutdown(struct uart_port *port)
	up->ier = 0;		up->ier = 0;
	serial_port_out(port, UART_IER, 0);		serial_port_out(port, UART_IER, 0);

			if (up->dma)
			serial8250_release_dma(up);

	spin_lock_irqsave(&port->lock, flags);		spin_lock_irqsave(&port->lock, flags);
	if (port->flags & UPF_FOURPORT) {		if (port->flags & UPF_FOURPORT) {
	/* reset interrupts on the AST Fourport board */		/* reset interrupts on the AST Fourport board */
	@@ -3217,6 +3240,8 @@ int serial8250_register_8250_port(struct uart_8250_port *up)
	uart->dl_read = up->dl_read;		uart->dl_read = up->dl_read;
	if (up->dl_write)		if (up->dl_write)
	uart->dl_write = up->dl_write;		uart->dl_write = up->dl_write;
			if (up->dma)
			uart->dma = up->dma;

	if (serial8250_isa_config != NULL)		if (serial8250_isa_config != NULL)
	serial8250_isa_config(0, &uart->port,		serial8250_isa_config(0, &uart->port,

drivers/tty/serial/8250/8250.h

+50 −0

Original line number	Original line	Diff line number	Diff line
	@@ -12,6 +12,35 @@
	*/		*/

	#include <linux/serial_8250.h>		#include <linux/serial_8250.h>
			#include <linux/dmaengine.h>

			struct uart_8250_dma {
			dma_filter_fn fn;
			void *rx_param;
			void *tx_param;

			int rx_chan_id;
			int tx_chan_id;

			struct dma_slave_config rxconf;
			struct dma_slave_config txconf;

			struct dma_chan *rxchan;
			struct dma_chan *txchan;

			dma_addr_t rx_addr;
			dma_addr_t tx_addr;

			dma_cookie_t rx_cookie;
			dma_cookie_t tx_cookie;

			void *rx_buf;

			size_t rx_size;
			size_t tx_size;

			unsigned char tx_running:1;
			};

	struct old_serial_port {		struct old_serial_port {
	unsigned int uart;		unsigned int uart;
	@@ -142,3 +171,24 @@ static inline int is_omap1510_8250(struct uart_8250_port *pt)
	return 0;		return 0;
	}		}
	#endif		#endif

			#ifdef CONFIG_SERIAL_8250_DMA
			extern int serial8250_tx_dma(struct uart_8250_port *);
			extern int serial8250_rx_dma(struct uart_8250_port *, unsigned int iir);
			extern int serial8250_request_dma(struct uart_8250_port *);
			extern void serial8250_release_dma(struct uart_8250_port *);
			#else
			static inline int serial8250_tx_dma(struct uart_8250_port *p)
			{
			return -1;
			}
			static inline int serial8250_rx_dma(struct uart_8250_port *p, unsigned int iir)
			{
			return -1;
			}
			static inline int serial8250_request_dma(struct uart_8250_port *p)
			{
			return -1;
			}
			static inline void serial8250_release_dma(struct uart_8250_port *p) { }
			#endif

drivers/tty/serial/8250/8250_dma.c

0 → 100644

+213 −0

Original line number	Original line	Diff line number	Diff line
			/*
			* 8250_dma.c - DMA Engine API support for 8250.c
			*
			* Copyright (C) 2013 Intel Corporation
			*
			* This program is free software; you can redistribute it and/or modify
			* it under the terms of the GNU General Public License as published by
			* the Free Software Foundation; either version 2 of the License, or
			* (at your option) any later version.
			*/
			#include <linux/tty.h>
			#include <linux/tty_flip.h>
			#include <linux/serial_reg.h>
			#include <linux/dma-mapping.h>

			#include "8250.h"

			static void __dma_tx_complete(void *param)
			{
			struct uart_8250_port *p = param;
			struct uart_8250_dma *dma = p->dma;
			struct circ_buf *xmit = &p->port.state->xmit;

			dma->tx_running = 0;

			dma_sync_single_for_cpu(dma->txchan->device->dev, dma->tx_addr,
			UART_XMIT_SIZE, DMA_TO_DEVICE);

			xmit->tail += dma->tx_size;
			xmit->tail &= UART_XMIT_SIZE - 1;
			p->port.icount.tx += dma->tx_size;

			if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
			uart_write_wakeup(&p->port);

			if (!uart_circ_empty(xmit) && !uart_tx_stopped(&p->port)) {
			serial8250_tx_dma(p);
			uart_write_wakeup(&p->port);
			}
			}

			static void __dma_rx_complete(void *param)
			{
			struct uart_8250_port *p = param;
			struct uart_8250_dma *dma = p->dma;
			struct tty_struct *tty = p->port.state->port.tty;
			struct dma_tx_state state;

			dma_sync_single_for_cpu(dma->rxchan->device->dev, dma->rx_addr,
			dma->rx_size, DMA_FROM_DEVICE);

			dmaengine_tx_status(dma->rxchan, dma->rx_cookie, &state);
			dmaengine_terminate_all(dma->rxchan);

			tty_insert_flip_string(tty, dma->rx_buf, dma->rx_size - state.residue);
			p->port.icount.rx += dma->rx_size - state.residue;

			tty_flip_buffer_push(tty);
			}

			int serial8250_tx_dma(struct uart_8250_port *p)
			{
			struct uart_8250_dma *dma = p->dma;
			struct circ_buf *xmit = &p->port.state->xmit;
			struct dma_async_tx_descriptor *desc;

			if (dma->tx_running) {
			uart_write_wakeup(&p->port);
			return -EBUSY;
			}

			dma->tx_size = CIRC_CNT_TO_END(xmit->head, xmit->tail, UART_XMIT_SIZE);

			desc = dmaengine_prep_slave_single(dma->txchan,
			dma->tx_addr + xmit->tail,
			dma->tx_size, DMA_MEM_TO_DEV,
			DMA_PREP_INTERRUPT \| DMA_CTRL_ACK);
			if (!desc)
			return -EBUSY;

			dma->tx_running = 1;

			desc->callback = __dma_tx_complete;
			desc->callback_param = p;

			dma->tx_cookie = dmaengine_submit(desc);

			dma_sync_single_for_device(dma->txchan->device->dev, dma->tx_addr,
			UART_XMIT_SIZE, DMA_TO_DEVICE);

			dma_async_issue_pending(dma->txchan);

			return 0;
			}
			EXPORT_SYMBOL_GPL(serial8250_tx_dma);

			int serial8250_rx_dma(struct uart_8250_port *p, unsigned int iir)
			{
			struct uart_8250_dma *dma = p->dma;
			struct dma_async_tx_descriptor *desc;
			struct dma_tx_state state;
			int dma_status;

			/*
			* If RCVR FIFO trigger level was not reached, complete the transfer and
			* let 8250.c copy the remaining data.
			*/
			if ((iir & 0x3f) == UART_IIR_RX_TIMEOUT) {
			dma_status = dmaengine_tx_status(dma->rxchan, dma->rx_cookie,
			&state);
			if (dma_status == DMA_IN_PROGRESS) {
			dmaengine_pause(dma->rxchan);
			__dma_rx_complete(p);
			}
			return -ETIMEDOUT;
			}

			desc = dmaengine_prep_slave_single(dma->rxchan, dma->rx_addr,
			dma->rx_size, DMA_DEV_TO_MEM,
			DMA_PREP_INTERRUPT \| DMA_CTRL_ACK);
			if (!desc)
			return -EBUSY;

			desc->callback = __dma_rx_complete;
			desc->callback_param = p;

			dma->rx_cookie = dmaengine_submit(desc);

			dma_sync_single_for_device(dma->rxchan->device->dev, dma->rx_addr,
			dma->rx_size, DMA_FROM_DEVICE);

			dma_async_issue_pending(dma->rxchan);

			return 0;
			}
			EXPORT_SYMBOL_GPL(serial8250_rx_dma);

			int serial8250_request_dma(struct uart_8250_port *p)
			{
			struct uart_8250_dma *dma = p->dma;
			dma_cap_mask_t mask;

			dma->rxconf.src_addr = p->port.mapbase + UART_RX;
			dma->txconf.dst_addr = p->port.mapbase + UART_TX;

			dma_cap_zero(mask);
			dma_cap_set(DMA_SLAVE, mask);

			/* Get a channel for RX */
			dma->rxchan = dma_request_channel(mask, dma->fn, dma->rx_param);
			if (!dma->rxchan)
			return -ENODEV;

			dmaengine_slave_config(dma->rxchan, &dma->rxconf);

			/* Get a channel for TX */
			dma->txchan = dma_request_channel(mask, dma->fn, dma->tx_param);
			if (!dma->txchan) {
			dma_release_channel(dma->rxchan);
			return -ENODEV;
			}

			dmaengine_slave_config(dma->txchan, &dma->txconf);

			/* RX buffer */
			if (!dma->rx_size)
			dma->rx_size = PAGE_SIZE;

			dma->rx_buf = dma_alloc_coherent(dma->rxchan->device->dev, dma->rx_size,
			&dma->rx_addr, GFP_KERNEL);
			if (!dma->rx_buf) {
			dma_release_channel(dma->rxchan);
			dma_release_channel(dma->txchan);
			return -ENOMEM;
			}

			/* TX buffer */
			dma->tx_addr = dma_map_single(dma->txchan->device->dev,
			p->port.state->xmit.buf,
			UART_XMIT_SIZE,
			DMA_TO_DEVICE);

			dev_dbg_ratelimited(p->port.dev, "got both dma channels\n");

			return 0;
			}
			EXPORT_SYMBOL_GPL(serial8250_request_dma);

			void serial8250_release_dma(struct uart_8250_port *p)
			{
			struct uart_8250_dma *dma = p->dma;

			if (!dma)
			return;

			/* Release RX resources */
			dmaengine_terminate_all(dma->rxchan);
			dma_free_coherent(dma->rxchan->device->dev, dma->rx_size, dma->rx_buf,
			dma->rx_addr);
			dma_release_channel(dma->rxchan);
			dma->rxchan = NULL;

			/* Release TX resources */
			dmaengine_terminate_all(dma->txchan);
			dma_unmap_single(dma->txchan->device->dev, dma->tx_addr,
			UART_XMIT_SIZE, DMA_TO_DEVICE);
			dma_release_channel(dma->txchan);
			dma->txchan = NULL;
			dma->tx_running = 0;

			dev_dbg_ratelimited(p->port.dev, "dma channels released\n");
			}
			EXPORT_SYMBOL_GPL(serial8250_release_dma);

drivers/tty/serial/8250/Kconfig

+8 −0

Original line number	Original line	Diff line number	Diff line
	@@ -84,6 +84,14 @@ config SERIAL_8250_GSC
	depends on SERIAL_8250 && GSC		depends on SERIAL_8250 && GSC
	default SERIAL_8250		default SERIAL_8250

			config SERIAL_8250_DMA
			bool "DMA support for 16550 compatible UART controllers" if EXPERT
			depends on SERIAL_8250 && DMADEVICES=y
			default SERIAL_8250
			help
			This builds DMA support that can be used with 8250/16650
			compatible UART controllers that support DMA signaling.

	config SERIAL_8250_PCI		config SERIAL_8250_PCI
	tristate "8250/16550 PCI device support" if EXPERT		tristate "8250/16550 PCI device support" if EXPERT
	depends on SERIAL_8250 && PCI		depends on SERIAL_8250 && PCI

drivers/tty/serial/8250/Makefile

+1 −0

Original line number	Original line	Diff line number	Diff line
	@@ -5,6 +5,7 @@
	obj-$(CONFIG_SERIAL_8250) += 8250_core.o		obj-$(CONFIG_SERIAL_8250) += 8250_core.o
	8250_core-y := 8250.o		8250_core-y := 8250.o
	8250_core-$(CONFIG_SERIAL_8250_PNP) += 8250_pnp.o		8250_core-$(CONFIG_SERIAL_8250_PNP) += 8250_pnp.o
			8250_core-$(CONFIG_SERIAL_8250_DMA) += 8250_dma.o
	obj-$(CONFIG_SERIAL_8250_GSC) += 8250_gsc.o		obj-$(CONFIG_SERIAL_8250_GSC) += 8250_gsc.o
	obj-$(CONFIG_SERIAL_8250_PCI) += 8250_pci.o		obj-$(CONFIG_SERIAL_8250_PCI) += 8250_pci.o
	obj-$(CONFIG_SERIAL_8250_HP300) += 8250_hp300.o		obj-$(CONFIG_SERIAL_8250_HP300) += 8250_hp300.o