serial: 8250: Use port lock wrappers

When a serial port is used for kernel console output, then all
modifications to the UART registers which are done from other contexts,
e.g. getty, termios, are interference points for the kernel console.

So far this has been ignored and the printk output is based on the
principle of hope. The rework of the console infrastructure which aims to
support threaded and atomic consoles, requires to mark sections which
modify the UART registers as unsafe. This allows the atomic write function
to make informed decisions and eventually to restore operational state. It
also allows to prevent the regular UART code from modifying UART registers
while printk output is in progress.

All modifications of UART registers are guarded by the UART port lock,
which provides an obvious synchronization point with the console
infrastructure.

To avoid adding this functionality to all UART drivers, wrap the
spin_[un]lock*() invocations for uart_port::lock into helper functions
which just contain the spin_[un]lock*() invocations for now. In a
subsequent step these helpers will gain the console synchronization
mechanisms.

Converted with coccinelle. No functional change.

Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
Reviewed-by: Ilpo Järvinen <ilpo.jarvinen@linux.intel.com>
Signed-off-by: John Ogness <john.ogness@linutronix.de>
Link: https://lore.kernel.org/r/20230914183831.587273-7-john.ogness@linutronix.de
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

diff --git a/drivers/tty/serial/8250/8250_core.c b/drivers/tty/serial/8250/8250_core.c
index 3449f8790e462e269df4c454fb37bfde330bed7e..904e319e6b4a3576eca555af04e0c1fac91a7d35 100644 (file)
--- a/drivers/tty/serial/8250/8250_core.c
+++ b/drivers/tty/serial/8250/8250_core.c
@@ -259,7 +259,7 @@ static void serial8250_backup_timeout(struct timer_list *t)
        unsigned int iir, ier = 0, lsr;
        unsigned long flags;
 
-       spin_lock_irqsave(&up->port.lock, flags);
+       uart_port_lock_irqsave(&up->port, &flags);
 
        /*
         * Must disable interrupts or else we risk racing with the interrupt
@@ -292,7 +292,7 @@ static void serial8250_backup_timeout(struct timer_list *t)
        if (up->port.irq)
                serial_out(up, UART_IER, ier);
 
-       spin_unlock_irqrestore(&up->port.lock, flags);
+       uart_port_unlock_irqrestore(&up->port, flags);
 
        /* Standard timer interval plus 0.2s to keep the port running */
        mod_timer(&up->timer,
@@ -992,11 +992,11 @@ static void serial_8250_overrun_backoff_work(struct work_struct *work)
        struct uart_port *port = &up->port;
        unsigned long flags;
 
-       spin_lock_irqsave(&port->lock, flags);
+       uart_port_lock_irqsave(port, &flags);
        up->ier |= UART_IER_RLSI | UART_IER_RDI;
        up->port.read_status_mask |= UART_LSR_DR;
        serial_out(up, UART_IER, up->ier);
-       spin_unlock_irqrestore(&port->lock, flags);
+       uart_port_unlock_irqrestore(port, flags);
 }
 
 /**
@@ -1194,9 +1194,9 @@ void serial8250_unregister_port(int line)
        if (uart->em485) {
                unsigned long flags;
 
-               spin_lock_irqsave(&uart->port.lock, flags);
+               uart_port_lock_irqsave(&uart->port, &flags);
                serial8250_em485_destroy(uart);
-               spin_unlock_irqrestore(&uart->port.lock, flags);
+               uart_port_unlock_irqrestore(&uart->port, flags);
        }
 
        uart_remove_one_port(&serial8250_reg, &uart->port);

diff --git a/drivers/tty/serial/8250/8250_port.c b/drivers/tty/serial/8250/8250_port.c
index a064698c2be07117b99852b8559ff02629a531b2..41d0ce7d0cfd50adafd8bb1712ad724d0e51bb13 100644 (file)
--- a/drivers/tty/serial/8250/8250_port.c
+++ b/drivers/tty/serial/8250/8250_port.c
@@ -689,7 +689,7 @@ static void serial8250_set_sleep(struct uart_8250_port *p, int sleep)
 
        if (p->capabilities & UART_CAP_SLEEP) {
                /* Synchronize UART_IER access against the console. */
-               spin_lock_irq(&p->port.lock);
+               uart_port_lock_irq(&p->port);
                if (p->capabilities & UART_CAP_EFR) {
                        lcr = serial_in(p, UART_LCR);
                        efr = serial_in(p, UART_EFR);
@@ -703,7 +703,7 @@ static void serial8250_set_sleep(struct uart_8250_port *p, int sleep)
                        serial_out(p, UART_EFR, efr);
                        serial_out(p, UART_LCR, lcr);
                }
-               spin_unlock_irq(&p->port.lock);
+               uart_port_unlock_irq(&p->port);
        }
 
        serial8250_rpm_put(p);
@@ -746,9 +746,9 @@ static void enable_rsa(struct uart_8250_port *up)
 {
        if (up->port.type == PORT_RSA) {
                if (up->port.uartclk != SERIAL_RSA_BAUD_BASE * 16) {
-                       spin_lock_irq(&up->port.lock);
+                       uart_port_lock_irq(&up->port);
                        __enable_rsa(up);
-                       spin_unlock_irq(&up->port.lock);
+                       uart_port_unlock_irq(&up->port);
                }
                if (up->port.uartclk == SERIAL_RSA_BAUD_BASE * 16)
                        serial_out(up, UART_RSA_FRR, 0);
@@ -768,7 +768,7 @@ static void disable_rsa(struct uart_8250_port *up)
 
        if (up->port.type == PORT_RSA &&
            up->port.uartclk == SERIAL_RSA_BAUD_BASE * 16) {
-               spin_lock_irq(&up->port.lock);
+               uart_port_lock_irq(&up->port);
 
                mode = serial_in(up, UART_RSA_MSR);
                result = !(mode & UART_RSA_MSR_FIFO);
@@ -781,7 +781,7 @@ static void disable_rsa(struct uart_8250_port *up)
 
                if (result)
                        up->port.uartclk = SERIAL_RSA_BAUD_BASE_LO * 16;
-               spin_unlock_irq(&up->port.lock);
+               uart_port_unlock_irq(&up->port);
        }
 }
 #endif /* CONFIG_SERIAL_8250_RSA */
@@ -1171,7 +1171,7 @@ static void autoconfig(struct uart_8250_port *up)
         *
         * Synchronize UART_IER access against the console.
         */
-       spin_lock_irqsave(&port->lock, flags);
+       uart_port_lock_irqsave(port, &flags);
 
        up->capabilities = 0;
        up->bugs = 0;
@@ -1210,7 +1210,7 @@ static void autoconfig(struct uart_8250_port *up)
                        /*
                         * We failed; there's nothing here
                         */
-                       spin_unlock_irqrestore(&port->lock, flags);
+                       uart_port_unlock_irqrestore(port, flags);
                        DEBUG_AUTOCONF("IER test failed (%02x, %02x) ",
                                       scratch2, scratch3);
                        goto out;
@@ -1234,7 +1234,7 @@ static void autoconfig(struct uart_8250_port *up)
                status1 = serial_in(up, UART_MSR) & UART_MSR_STATUS_BITS;
                serial8250_out_MCR(up, save_mcr);
                if (status1 != (UART_MSR_DCD | UART_MSR_CTS)) {
-                       spin_unlock_irqrestore(&port->lock, flags);
+                       uart_port_unlock_irqrestore(port, flags);
                        DEBUG_AUTOCONF("LOOP test failed (%02x) ",
                                       status1);
                        goto out;
@@ -1303,7 +1303,7 @@ static void autoconfig(struct uart_8250_port *up)
        serial8250_clear_IER(up);
 
 out_unlock:
-       spin_unlock_irqrestore(&port->lock, flags);
+       uart_port_unlock_irqrestore(port, flags);
 
        /*
         * Check if the device is a Fintek F81216A
@@ -1343,9 +1343,9 @@ static void autoconfig_irq(struct uart_8250_port *up)
        probe_irq_off(probe_irq_on());
        save_mcr = serial8250_in_MCR(up);
        /* Synchronize UART_IER access against the console. */
-       spin_lock_irq(&port->lock);
+       uart_port_lock_irq(port);
        save_ier = serial_in(up, UART_IER);
-       spin_unlock_irq(&port->lock);
+       uart_port_unlock_irq(port);
        serial8250_out_MCR(up, UART_MCR_OUT1 | UART_MCR_OUT2);
 
        irqs = probe_irq_on();
@@ -1358,9 +1358,9 @@ static void autoconfig_irq(struct uart_8250_port *up)
                        UART_MCR_DTR | UART_MCR_RTS | UART_MCR_OUT2);
        }
        /* Synchronize UART_IER access against the console. */
-       spin_lock_irq(&port->lock);
+       uart_port_lock_irq(port);
        serial_out(up, UART_IER, UART_IER_ALL_INTR);
-       spin_unlock_irq(&port->lock);
+       uart_port_unlock_irq(port);
        serial_in(up, UART_LSR);
        serial_in(up, UART_RX);
        serial_in(up, UART_IIR);
@@ -1371,9 +1371,9 @@ static void autoconfig_irq(struct uart_8250_port *up)
 
        serial8250_out_MCR(up, save_mcr);
        /* Synchronize UART_IER access against the console. */
-       spin_lock_irq(&port->lock);
+       uart_port_lock_irq(port);
        serial_out(up, UART_IER, save_ier);
-       spin_unlock_irq(&port->lock);
+       uart_port_unlock_irq(port);
 
        if (port->flags & UPF_FOURPORT)
                outb_p(save_ICP, ICP);
@@ -1441,13 +1441,13 @@ static enum hrtimer_restart serial8250_em485_handle_stop_tx(struct hrtimer *t)
        unsigned long flags;
 
        serial8250_rpm_get(p);
-       spin_lock_irqsave(&p->port.lock, flags);
+       uart_port_lock_irqsave(&p->port, &flags);
        if (em485->active_timer == &em485->stop_tx_timer) {
                p->rs485_stop_tx(p);
                em485->active_timer = NULL;
                em485->tx_stopped = true;
        }
-       spin_unlock_irqrestore(&p->port.lock, flags);
+       uart_port_unlock_irqrestore(&p->port, flags);
        serial8250_rpm_put(p);
 
        return HRTIMER_NORESTART;
@@ -1629,12 +1629,12 @@ static enum hrtimer_restart serial8250_em485_handle_start_tx(struct hrtimer *t)
        struct uart_8250_port *p = em485->port;
        unsigned long flags;
 
-       spin_lock_irqsave(&p->port.lock, flags);
+       uart_port_lock_irqsave(&p->port, &flags);
        if (em485->active_timer == &em485->start_tx_timer) {
                __start_tx(&p->port);
                em485->active_timer = NULL;
        }
-       spin_unlock_irqrestore(&p->port.lock, flags);
+       uart_port_unlock_irqrestore(&p->port, flags);
 
        return HRTIMER_NORESTART;
 }
@@ -1917,7 +1917,7 @@ int serial8250_handle_irq(struct uart_port *port, unsigned int iir)
        if (iir & UART_IIR_NO_INT)
                return 0;
 
-       spin_lock_irqsave(&port->lock, flags);
+       uart_port_lock_irqsave(port, &flags);
 
        status = serial_lsr_in(up);
 
@@ -1984,9 +1984,9 @@ static int serial8250_tx_threshold_handle_irq(struct uart_port *port)
        if ((iir & UART_IIR_ID) == UART_IIR_THRI) {
                struct uart_8250_port *up = up_to_u8250p(port);
 
-               spin_lock_irqsave(&port->lock, flags);
+               uart_port_lock_irqsave(port, &flags);
                serial8250_tx_chars(up);
-               spin_unlock_irqrestore(&port->lock, flags);
+               uart_port_unlock_irqrestore(port, flags);
        }
 
        iir = serial_port_in(port, UART_IIR);
@@ -2001,10 +2001,10 @@ static unsigned int serial8250_tx_empty(struct uart_port *port)
 
        serial8250_rpm_get(up);
 
-       spin_lock_irqsave(&port->lock, flags);
+       uart_port_lock_irqsave(port, &flags);
        if (!serial8250_tx_dma_running(up) && uart_lsr_tx_empty(serial_lsr_in(up)))
                result = TIOCSER_TEMT;
-       spin_unlock_irqrestore(&port->lock, flags);
+       uart_port_unlock_irqrestore(port, flags);
 
        serial8250_rpm_put(up);
 
@@ -2066,13 +2066,13 @@ static void serial8250_break_ctl(struct uart_port *port, int break_state)
        unsigned long flags;
 
        serial8250_rpm_get(up);
-       spin_lock_irqsave(&port->lock, flags);
+       uart_port_lock_irqsave(port, &flags);
        if (break_state == -1)
                up->lcr |= UART_LCR_SBC;
        else
                up->lcr &= ~UART_LCR_SBC;
        serial_port_out(port, UART_LCR, up->lcr);
-       spin_unlock_irqrestore(&port->lock, flags);
+       uart_port_unlock_irqrestore(port, flags);
        serial8250_rpm_put(up);
 }
 
@@ -2207,7 +2207,7 @@ int serial8250_do_startup(struct uart_port *port)
                 *
                 * Synchronize UART_IER access against the console.
                 */
-               spin_lock_irqsave(&port->lock, flags);
+               uart_port_lock_irqsave(port, &flags);
                up->acr = 0;
                serial_port_out(port, UART_LCR, UART_LCR_CONF_MODE_B);
                serial_port_out(port, UART_EFR, UART_EFR_ECB);
@@ -2217,7 +2217,7 @@ int serial8250_do_startup(struct uart_port *port)
                serial_port_out(port, UART_LCR, UART_LCR_CONF_MODE_B);
                serial_port_out(port, UART_EFR, UART_EFR_ECB);
                serial_port_out(port, UART_LCR, 0);
-               spin_unlock_irqrestore(&port->lock, flags);
+               uart_port_unlock_irqrestore(port, flags);
        }
 
        if (port->type == PORT_DA830) {
@@ -2226,10 +2226,10 @@ int serial8250_do_startup(struct uart_port *port)
                 *
                 * Synchronize UART_IER access against the console.
                 */
-               spin_lock_irqsave(&port->lock, flags);
+               uart_port_lock_irqsave(port, &flags);
                serial_port_out(port, UART_IER, 0);
                serial_port_out(port, UART_DA830_PWREMU_MGMT, 0);
-               spin_unlock_irqrestore(&port->lock, flags);
+               uart_port_unlock_irqrestore(port, flags);
                mdelay(10);
 
                /* Enable Tx, Rx and free run mode */
@@ -2343,7 +2343,7 @@ int serial8250_do_startup(struct uart_port *port)
                 *
                 * Synchronize UART_IER access against the console.
                 */
-               spin_lock_irqsave(&port->lock, flags);
+               uart_port_lock_irqsave(port, &flags);
 
                wait_for_xmitr(up, UART_LSR_THRE);
                serial_port_out_sync(port, UART_IER, UART_IER_THRI);
@@ -2355,7 +2355,7 @@ int serial8250_do_startup(struct uart_port *port)
                iir = serial_port_in(port, UART_IIR);
                serial_port_out(port, UART_IER, 0);
 
-               spin_unlock_irqrestore(&port->lock, flags);
+               uart_port_unlock_irqrestore(port, flags);
 
                if (port->irqflags & IRQF_SHARED)
                        enable_irq(port->irq);
@@ -2378,7 +2378,7 @@ int serial8250_do_startup(struct uart_port *port)
         */
        serial_port_out(port, UART_LCR, UART_LCR_WLEN8);
 
-       spin_lock_irqsave(&port->lock, flags);
+       uart_port_lock_irqsave(port, &flags);
        if (up->port.flags & UPF_FOURPORT) {
                if (!up->port.irq)
                        up->port.mctrl |= TIOCM_OUT1;
@@ -2424,7 +2424,7 @@ int serial8250_do_startup(struct uart_port *port)
        }
 
 dont_test_tx_en:
-       spin_unlock_irqrestore(&port->lock, flags);
+       uart_port_unlock_irqrestore(port, flags);
 
        /*
         * Clear the interrupt registers again for luck, and clear the
@@ -2495,17 +2495,17 @@ void serial8250_do_shutdown(struct uart_port *port)
         *
         * Synchronize UART_IER access against the console.
         */
-       spin_lock_irqsave(&port->lock, flags);
+       uart_port_lock_irqsave(port, &flags);
        up->ier = 0;
        serial_port_out(port, UART_IER, 0);
-       spin_unlock_irqrestore(&port->lock, flags);
+       uart_port_unlock_irqrestore(port, flags);
 
        synchronize_irq(port->irq);
 
        if (up->dma)
                serial8250_release_dma(up);
 
-       spin_lock_irqsave(&port->lock, flags);
+       uart_port_lock_irqsave(port, &flags);
        if (port->flags & UPF_FOURPORT) {
                /* reset interrupts on the AST Fourport board */
                inb((port->iobase & 0xfe0) | 0x1f);
@@ -2514,7 +2514,7 @@ void serial8250_do_shutdown(struct uart_port *port)
                port->mctrl &= ~TIOCM_OUT2;
 
        serial8250_set_mctrl(port, port->mctrl);
-       spin_unlock_irqrestore(&port->lock, flags);
+       uart_port_unlock_irqrestore(port, flags);
 
        /*
         * Disable break condition and FIFOs
@@ -2750,14 +2750,14 @@ void serial8250_update_uartclk(struct uart_port *port, unsigned int uartclk)
        quot = serial8250_get_divisor(port, baud, &frac);
 
        serial8250_rpm_get(up);
-       spin_lock_irqsave(&port->lock, flags);
+       uart_port_lock_irqsave(port, &flags);
 
        uart_update_timeout(port, termios->c_cflag, baud);
 
        serial8250_set_divisor(port, baud, quot, frac);
        serial_port_out(port, UART_LCR, up->lcr);
 
-       spin_unlock_irqrestore(&port->lock, flags);
+       uart_port_unlock_irqrestore(port, flags);
        serial8250_rpm_put(up);
 
 out_unlock:
@@ -2794,7 +2794,7 @@ serial8250_do_set_termios(struct uart_port *port, struct ktermios *termios,
         * Synchronize UART_IER access against the console.
         */
        serial8250_rpm_get(up);
-       spin_lock_irqsave(&port->lock, flags);
+       uart_port_lock_irqsave(port, &flags);
 
        up->lcr = cval;                                 /* Save computed LCR */
 
@@ -2897,7 +2897,7 @@ serial8250_do_set_termios(struct uart_port *port, struct ktermios *termios,
                serial_port_out(port, UART_FCR, up->fcr);       /* set fcr */
        }
        serial8250_set_mctrl(port, port->mctrl);
-       spin_unlock_irqrestore(&port->lock, flags);
+       uart_port_unlock_irqrestore(port, flags);
        serial8250_rpm_put(up);
 
        /* Don't rewrite B0 */
@@ -2920,15 +2920,15 @@ void serial8250_do_set_ldisc(struct uart_port *port, struct ktermios *termios)
 {
        if (termios->c_line == N_PPS) {
                port->flags |= UPF_HARDPPS_CD;
-               spin_lock_irq(&port->lock);
+               uart_port_lock_irq(port);
                serial8250_enable_ms(port);
-               spin_unlock_irq(&port->lock);
+               uart_port_unlock_irq(port);
        } else {
                port->flags &= ~UPF_HARDPPS_CD;
                if (!UART_ENABLE_MS(port, termios->c_cflag)) {
-                       spin_lock_irq(&port->lock);
+                       uart_port_lock_irq(port);
                        serial8250_disable_ms(port);
-                       spin_unlock_irq(&port->lock);
+                       uart_port_unlock_irq(port);
                }
        }
 }
@@ -3402,9 +3402,9 @@ void serial8250_console_write(struct uart_8250_port *up, const char *s,
        touch_nmi_watchdog();
 
        if (oops_in_progress)
-               locked = spin_trylock_irqsave(&port->lock, flags);
+               locked = uart_port_trylock_irqsave(port, &flags);
        else
-               spin_lock_irqsave(&port->lock, flags);
+               uart_port_lock_irqsave(port, &flags);
 
        /*
         *      First save the IER then disable the interrupts
@@ -3474,7 +3474,7 @@ void serial8250_console_write(struct uart_8250_port *up, const char *s,
                serial8250_modem_status(up);
 
        if (locked)
-               spin_unlock_irqrestore(&port->lock, flags);
+               uart_port_unlock_irqrestore(port, flags);
 }
 
 static unsigned int probe_baud(struct uart_port *port)