Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit da3564ee authored by Tomoya MORINAGA's avatar Tomoya MORINAGA Committed by Greg Kroah-Hartman
Browse files

pch_uart: add multi-scatter processing 



Currently, this driver can handle only single scatterlist.
Thus, it can't send data beyond FIFO size.

This patch enables this driver can handle multiple scatter list.

Signed-off-by: default avatarTomoya MORINAGA <tomoya-linux@dsn.okisemi.com>
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@suse.de>
parent 4c377058

drivers/tty/serial/pch_uart.c

+89 −28
Original line number Diff line number Diff line
@@ -226,7 +226,8 @@ struct eg20t_port { 
	struct pch_dma_slave		param_rx;

	struct dma_chan			*chan_tx;

	struct dma_chan			*chan_rx;

	struct scatterlist		sg_tx;

	struct scatterlist		*sg_tx_p;

	int				nent;

	struct scatterlist		sg_rx;

	int				tx_dma_use;

	void				*rx_buf_virt;
@@ -595,16 +596,20 @@ static void pch_dma_rx_complete(void *arg) 
	struct eg20t_port *priv = arg;

	struct uart_port *port = &priv->port;

	struct tty_struct *tty = tty_port_tty_get(&port->state->port);

	int count;



	if (!tty) {

		pr_debug("%s:tty is busy now", __func__);

		return;

	}



	if (dma_push_rx(priv, priv->trigger_level))

	dma_sync_sg_for_cpu(port->dev, &priv->sg_rx, 1, DMA_FROM_DEVICE);

	count = dma_push_rx(priv, priv->trigger_level);

	if (count)

		tty_flip_buffer_push(tty);



	tty_kref_put(tty);

	async_tx_ack(priv->desc_rx);

	pch_uart_hal_enable_interrupt(priv, PCH_UART_HAL_RX_INT);

}



static void pch_dma_tx_complete(void *arg)
@@ -612,13 +617,21 @@ static void pch_dma_tx_complete(void *arg) 
	struct eg20t_port *priv = arg;

	struct uart_port *port = &priv->port;

	struct circ_buf *xmit = &port->state->xmit;

	struct scatterlist *sg = priv->sg_tx_p;

	int i;



	xmit->tail += sg_dma_len(&priv->sg_tx);

	for (i = 0; i < priv->nent; i++, sg++) {

		xmit->tail += sg_dma_len(sg);

		port->icount.tx += sg_dma_len(sg);

	}

	xmit->tail &= UART_XMIT_SIZE - 1;

	port->icount.tx += sg_dma_len(&priv->sg_tx);



	async_tx_ack(priv->desc_tx);

	dma_unmap_sg(port->dev, sg, priv->nent, DMA_TO_DEVICE);

	priv->tx_dma_use = 0;

	priv->nent = 0;

	kfree(priv->sg_tx_p);

	if (uart_circ_chars_pending(xmit))

		pch_uart_hal_enable_interrupt(priv, PCH_UART_HAL_TX_INT);

}



static int pop_tx(struct eg20t_port *priv, unsigned char *buf, int size)
@@ -682,7 +695,7 @@ static int dma_handle_rx(struct eg20t_port *priv) 


	sg_init_table(&priv->sg_rx, 1); /* Initialize SG table */



	sg_dma_len(sg) = priv->fifo_size;

	sg_dma_len(sg) = priv->trigger_level;



	sg_set_page(&priv->sg_rx, virt_to_page(priv->rx_buf_virt),

		     sg_dma_len(sg), (unsigned long)priv->rx_buf_virt &
@@ -692,7 +705,8 @@ static int dma_handle_rx(struct eg20t_port *priv) 


	desc = priv->chan_rx->device->device_prep_slave_sg(priv->chan_rx,

			sg, 1, DMA_FROM_DEVICE,

			DMA_PREP_INTERRUPT);

			DMA_PREP_INTERRUPT | DMA_CTRL_ACK);



	if (!desc)

		return 0;
@@ -731,6 +745,9 @@ static unsigned int handle_tx(struct eg20t_port *priv) 
		fifo_size--;

	}

	size = min(xmit->head - xmit->tail, fifo_size);

	if (size < 0)

		size = fifo_size;



	tx_size = pop_tx(priv, xmit->buf, size);

	if (tx_size > 0) {

		ret = pch_uart_hal_write(priv, xmit->buf, tx_size);
@@ -740,8 +757,10 @@ static unsigned int handle_tx(struct eg20t_port *priv) 


	priv->tx_empty = tx_empty;



	if (tx_empty)

	if (tx_empty) {

		pch_uart_hal_disable_interrupt(priv, PCH_UART_HAL_TX_INT);

		uart_write_wakeup(port);

	}



	return PCH_UART_HANDLED_TX_INT;

}
@@ -750,11 +769,16 @@ static unsigned int dma_handle_tx(struct eg20t_port *priv) 
{

	struct uart_port *port = &priv->port;

	struct circ_buf *xmit = &port->state->xmit;

	struct scatterlist *sg = &priv->sg_tx;

	struct scatterlist *sg;

	int nent;

	int fifo_size;

	int tx_empty;

	struct dma_async_tx_descriptor *desc;

	int num;

	int i;

	int bytes;

	int size;

	int rem;



	if (!priv->start_tx) {

		pr_info("%s:Tx isn't started. (%lu)\n", __func__, jiffies);
@@ -772,37 +796,68 @@ static unsigned int dma_handle_tx(struct eg20t_port *priv) 
		fifo_size--;

	}



	bytes = min((int)CIRC_CNT(xmit->head, xmit->tail,

			     UART_XMIT_SIZE), CIRC_CNT_TO_END(xmit->head,

			     xmit->tail, UART_XMIT_SIZE));

	if (!bytes) {

		pch_uart_hal_disable_interrupt(priv, PCH_UART_HAL_TX_INT);

		uart_write_wakeup(port);

		return 0;

	}



	if (bytes > fifo_size) {

		num = bytes / fifo_size + 1;

		size = fifo_size;

		rem = bytes % fifo_size;

	} else {

		num = 1;

		size = bytes;

		rem = bytes;

	}



	priv->tx_dma_use = 1;



	sg_init_table(&priv->sg_tx, 1); /* Initialize SG table */

	priv->sg_tx_p = kzalloc(sizeof(struct scatterlist)*num, GFP_ATOMIC);



	sg_init_table(priv->sg_tx_p, num); /* Initialize SG table */

	sg = priv->sg_tx_p;



	sg_set_page(&priv->sg_tx, virt_to_page(xmit->buf),

		    UART_XMIT_SIZE, (int)xmit->buf & ~PAGE_MASK);

	for (i = 0; i < num; i++, sg++) {

		if (i == (num - 1))

			sg_set_page(sg, virt_to_page(xmit->buf),

				    rem, fifo_size * i);

		else

			sg_set_page(sg, virt_to_page(xmit->buf),

				    size, fifo_size * i);

	}



	nent = dma_map_sg(port->dev, &priv->sg_tx, 1, DMA_TO_DEVICE);

	sg = priv->sg_tx_p;

	nent = dma_map_sg(port->dev, sg, num, DMA_TO_DEVICE);

	if (!nent) {

		pr_err("%s:dma_map_sg Failed\n", __func__);

		return 0;

	}

	priv->nent = nent;



	sg->offset = xmit->tail & (UART_XMIT_SIZE - 1);

	sg_dma_address(sg) = (sg_dma_address(sg) & ~(UART_XMIT_SIZE - 1)) +

			      sg->offset;

	sg_dma_len(sg) = min((int)CIRC_CNT(xmit->head, xmit->tail,

			     UART_XMIT_SIZE), CIRC_CNT_TO_END(xmit->head,

			     xmit->tail, UART_XMIT_SIZE));

	for (i = 0; i < nent; i++, sg++) {

		sg->offset = (xmit->tail & (UART_XMIT_SIZE - 1)) +

			      fifo_size * i;

		sg_dma_address(sg) = (sg_dma_address(sg) &

				    ~(UART_XMIT_SIZE - 1)) + sg->offset;

		if (i == (nent - 1))

			sg_dma_len(sg) = rem;

		else

			sg_dma_len(sg) = size;

	}



	desc = priv->chan_tx->device->device_prep_slave_sg(priv->chan_tx,

		sg, nent, DMA_TO_DEVICE, DMA_PREP_INTERRUPT | DMA_CTRL_ACK);

					priv->sg_tx_p, nent, DMA_TO_DEVICE,

					DMA_PREP_INTERRUPT | DMA_CTRL_ACK);

	if (!desc) {

		pr_err("%s:device_prep_slave_sg Failed\n", __func__);

		return 0;

	}



	dma_sync_sg_for_device(port->dev, sg, 1, DMA_TO_DEVICE);



	dma_sync_sg_for_device(port->dev, priv->sg_tx_p, nent, DMA_TO_DEVICE);

	priv->desc_tx = desc;

	desc->callback = pch_dma_tx_complete;

	desc->callback_param = priv;
@@ -857,10 +912,16 @@ static irqreturn_t pch_uart_interrupt(int irq, void *dev_id) 
			}

			break;

		case PCH_UART_IID_RDR:	/* Received Data Ready */

			if (priv->use_dma)

			if (priv->use_dma) {

				pch_uart_hal_disable_interrupt(priv,

							PCH_UART_HAL_RX_INT);

				ret = dma_handle_rx(priv);

			else

				if (!ret)

					pch_uart_hal_enable_interrupt(priv,

							PCH_UART_HAL_RX_INT);

			} else {

				ret = handle_rx(priv);

			}

			break;

		case PCH_UART_IID_RDR_TO:	/* Received Data Ready

						   (FIFO Timeout) */