[mirror_ubuntu-bionic-kernel.git] / drivers / tty / serial / 8250 / 8250_fsl.c

// SPDX-License-Identifier: GPL-2.0
#include <linux/serial_reg.h>
#include <linux/serial_8250.h>

#include "8250.h"

/*
 * Freescale 16550 UART "driver", Copyright (C) 2011 Paul Gortmaker.
 *
 * This isn't a full driver; it just provides an alternate IRQ
 * handler to deal with an errata.  Everything else is just
 * using the bog standard 8250 support.
 *
 * We follow code flow of serial8250_default_handle_irq() but add
 * a check for a break and insert a dummy read on the Rx for the
 * immediately following IRQ event.
 *
 * We re-use the already existing "bug handling" lsr_saved_flags
 * field to carry the "what we just did" information from the one
 * IRQ event to the next one.
 */

int fsl8250_handle_irq(struct uart_port *port)
{
	unsigned char lsr, orig_lsr;
	unsigned long flags;
	unsigned int iir;
	struct uart_8250_port *up = up_to_u8250p(port);

	spin_lock_irqsave(&up->port.lock, flags);

	iir = port->serial_in(port, UART_IIR);
	if (iir & UART_IIR_NO_INT) {
		spin_unlock_irqrestore(&up->port.lock, flags);
		return 0;
	}

	/* This is the WAR; if last event was BRK, then read and return */
	if (unlikely(up->lsr_saved_flags & UART_LSR_BI)) {
		up->lsr_saved_flags &= ~UART_LSR_BI;
		port->serial_in(port, UART_RX);
		spin_unlock_irqrestore(&up->port.lock, flags);
		return 1;
	}

	lsr = orig_lsr = up->port.serial_in(&up->port, UART_LSR);

	/* Process incoming characters first */
	if ((lsr & (UART_LSR_DR | UART_LSR_BI)) &&
	    (up->ier & (UART_IER_RLSI | UART_IER_RDI))) {
		lsr = serial8250_rx_chars(up, lsr);
	}

	/* Stop processing interrupts on input overrun */
	if ((orig_lsr & UART_LSR_OE) && (up->overrun_backoff_time_ms > 0)) {
		unsigned long delay;

		up->ier = port->serial_in(port, UART_IER);
		if (up->ier & (UART_IER_RLSI | UART_IER_RDI)) {
			port->ops->stop_rx(port);
		} else {
			/* Keep restarting the timer until
			 * the input overrun subsides.
			 */
			cancel_delayed_work(&up->overrun_backoff);
		}

		delay = msecs_to_jiffies(up->overrun_backoff_time_ms);
		schedule_delayed_work(&up->overrun_backoff, delay);
	}

	serial8250_modem_status(up);

	if (lsr & UART_LSR_THRE)
		serial8250_tx_chars(up);

	up->lsr_saved_flags = orig_lsr;
	spin_unlock_irqrestore(&up->port.lock, flags);
	return 1;
}
EXPORT_SYMBOL_GPL(fsl8250_handle_irq);
Commit	Line	Data
e3b3d0f5	1	// SPDX-License-Identifier: GPL-2.0
9deaa53a PG	2	#include <linux/serial_reg.h>
	3	#include <linux/serial_8250.h>
	4
	5	#include "8250.h"
	6
	7	/*
	8	* Freescale 16550 UART "driver", Copyright (C) 2011 Paul Gortmaker.
	9	*
9deaa53a PG	10	* This isn't a full driver; it just provides an alternate IRQ
	11	* handler to deal with an errata. Everything else is just
	12	* using the bog standard 8250 support.
	13	*
	14	* We follow code flow of serial8250_default_handle_irq() but add
	15	* a check for a break and insert a dummy read on the Rx for the
	16	* immediately following IRQ event.
	17	*
	18	* We re-use the already existing "bug handling" lsr_saved_flags
	19	* field to carry the "what we just did" information from the one
	20	* IRQ event to the next one.
	21	*/
	22
	23	int fsl8250_handle_irq(struct uart_port *port)
	24	{
	25	unsigned char lsr, orig_lsr;
	26	unsigned long flags;
	27	unsigned int iir;
b1261c86	28	struct uart_8250_port *up = up_to_u8250p(port);
9deaa53a PG	29
	30	spin_lock_irqsave(&up->port.lock, flags);
	31
	32	iir = port->serial_in(port, UART_IIR);
	33	if (iir & UART_IIR_NO_INT) {
	34	spin_unlock_irqrestore(&up->port.lock, flags);
	35	return 0;
	36	}
	37
	38	/* This is the WAR; if last event was BRK, then read and return */
	39	if (unlikely(up->lsr_saved_flags & UART_LSR_BI)) {
	40	up->lsr_saved_flags &= ~UART_LSR_BI;
	41	port->serial_in(port, UART_RX);
	42	spin_unlock_irqrestore(&up->port.lock, flags);
	43	return 1;
	44	}
	45
	46	lsr = orig_lsr = up->port.serial_in(&up->port, UART_LSR);
	47
886979da DD	48	/* Process incoming characters first */
	49	if ((lsr & (UART_LSR_DR \| UART_LSR_BI)) &&
	50	(up->ier & (UART_IER_RLSI \| UART_IER_RDI))) {
9deaa53a	51	lsr = serial8250_rx_chars(up, lsr);
886979da DD	52	}
	53
	54	/* Stop processing interrupts on input overrun */
	55	if ((orig_lsr & UART_LSR_OE) && (up->overrun_backoff_time_ms > 0)) {
	56	unsigned long delay;
	57
	58	up->ier = port->serial_in(port, UART_IER);
	59	if (up->ier & (UART_IER_RLSI \| UART_IER_RDI)) {
	60	port->ops->stop_rx(port);
	61	} else {
	62	/* Keep restarting the timer until
	63	* the input overrun subsides.
	64	*/
	65	cancel_delayed_work(&up->overrun_backoff);
	66	}
	67
	68	delay = msecs_to_jiffies(up->overrun_backoff_time_ms);
	69	schedule_delayed_work(&up->overrun_backoff, delay);
	70	}
9deaa53a PG	71
	72	serial8250_modem_status(up);
	73
	74	if (lsr & UART_LSR_THRE)
	75	serial8250_tx_chars(up);
	76
	77	up->lsr_saved_flags = orig_lsr;
	78	spin_unlock_irqrestore(&up->port.lock, flags);
	79	return 1;
	80	}
bd63acf9	81	EXPORT_SYMBOL_GPL(fsl8250_handle_irq);