We're about to amend uart_get_rs485_mode() to support a GPIO pin for
rs485 bus termination.  Retrieving the GPIO descriptor may fail, so
allow uart_get_rs485_mode() to return an errno and change all callers
to check for failure.
The GPIO descriptor is going to be stored in struct uart_port.  Pass
that struct to uart_get_rs485_mode() in lieu of a struct device and
struct serial_rs485, both of which are directly accessible from struct
uart_port.
A few drivers call uart_get_rs485_mode() before setting the struct
device pointer in struct uart_port.  Shuffle those calls around where
necessary.
[Heiko Stuebner did the ar933x_uart.c portion, hence his Signed-off-by.]
Signed-off-by: Heiko Stuebner <heiko@sntech.de>
Signed-off-by: Lukas Wunner <lukas@wunner.de>
Link: https://lore.kernel.org/r/271e814af4b0db3bffbbb74abf2b46b75add4516.1589285873.git.lukas@wunner.de
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
 
 
                if (up->port.dev) {
                        uart->port.dev = up->port.dev;
-                       uart_get_rs485_mode(uart->port.dev, &uart->port.rs485);
+                       ret = uart_get_rs485_mode(&uart->port);
+                       if (ret)
+                               goto err;
                }
 
                if (up->port.flags & UPF_FIXED_TYPE)
 
                goto err_disable_clk;
        }
 
-       uart_get_rs485_mode(&pdev->dev, &port->rs485);
-
        port->mapbase = mem_res->start;
        port->line = id;
        port->irq = irq_res->start;
        baud = ar933x_uart_get_baud(port->uartclk, 0, AR933X_UART_MAX_STEP);
        up->max_baud = min_t(unsigned int, baud, AR933X_UART_MAX_BAUD);
 
+       ret = uart_get_rs485_mode(port);
+       if (ret)
+               goto err_disable_clk;
+
        up->gpios = mctrl_gpio_init(port, 0);
        if (IS_ERR(up->gpios) && PTR_ERR(up->gpios) != -ENOSYS)
                return PTR_ERR(up->gpios);
 
        atmel_init_property(atmel_port, pdev);
        atmel_set_ops(port);
 
-       uart_get_rs485_mode(&mpdev->dev, &port->rs485);
-
        port->iotype            = UPIO_MEM;
        port->flags             = UPF_BOOT_AUTOCONF | UPF_IOREMAP;
        port->ops               = &atmel_pops;
 
        memset(&atmel_port->rx_ring, 0, sizeof(atmel_port->rx_ring));
 
+       ret = uart_get_rs485_mode(port);
+       if (ret)
+               return ret;
+
        /* for console, the clock could already be configured */
        if (!atmel_port->clk) {
                atmel_port->clk = clk_get(&mpdev->dev, "usart");
 
        if (ret)
                goto failed_attach_port;
 
-       uart_get_rs485_mode(&pdev->dev, &sport->port.rs485);
+       ret = uart_get_rs485_mode(&sport->port);
+       if (ret)
+               goto failed_get_rs485;
 
        if (sport->port.rs485.flags & SER_RS485_RX_DURING_TX)
                dev_err(&pdev->dev, "driver doesn't support RX during TX\n");
 
        return 0;
 
+failed_get_rs485:
 failed_attach_port:
 failed_irq_request:
        lpuart_disable_clks(sport);
 
        sport->ucr4 = readl(sport->port.membase + UCR4);
        sport->ufcr = readl(sport->port.membase + UFCR);
 
-       uart_get_rs485_mode(&pdev->dev, &sport->port.rs485);
+       ret = uart_get_rs485_mode(&sport->port);
+       if (ret) {
+               clk_disable_unprepare(sport->clk_ipg);
+               return ret;
+       }
 
        if (sport->port.rs485.flags & SER_RS485_ENABLED &&
            (!sport->have_rtscts && !sport->have_rtsgpio))
 
        if (!np)
                return 0;
 
-       uart_get_rs485_mode(up->dev, rs485conf);
+       ret = uart_get_rs485_mode(&up->port);
+       if (ret)
+               return ret;
 
        if (of_property_read_bool(np, "rs485-rts-active-high")) {
                rs485conf->flags |= SER_RS485_RTS_ON_SEND;
 
  * This function implements the device tree binding described in
  * Documentation/devicetree/bindings/serial/rs485.txt.
  */
-void uart_get_rs485_mode(struct device *dev, struct serial_rs485 *rs485conf)
+int uart_get_rs485_mode(struct uart_port *port)
 {
+       struct serial_rs485 *rs485conf = &port->rs485;
+       struct device *dev = port->dev;
        u32 rs485_delay[2];
        int ret;
 
                rs485conf->flags &= ~SER_RS485_RTS_ON_SEND;
                rs485conf->flags |= SER_RS485_RTS_AFTER_SEND;
        }
+
+       return 0;
 }
 EXPORT_SYMBOL_GPL(uart_get_rs485_mode);
 
 
        if (!pdev->dev.of_node)
                return -ENODEV;
 
-       uart_get_rs485_mode(&pdev->dev, rs485conf);
-
-       return 0;
+       return uart_get_rs485_mode(port);
 }
 
 static int stm32_pending_rx(struct uart_port *port, u32 *sr, int *last_res,
 
        port->rs485_config = stm32_config_rs485;
 
-       stm32_init_rs485(port, pdev);
+       ret = stm32_init_rs485(port, pdev);
+       if (ret)
+               return ret;
 
        if (stm32port->info->cfg.has_wakeup) {
                stm32port->wakeirq = platform_get_irq(pdev, 1);
 
                                         (cflag) & CRTSCTS || \
                                         !((cflag) & CLOCAL))
 
-void uart_get_rs485_mode(struct device *dev, struct serial_rs485 *rs485conf);
+int uart_get_rs485_mode(struct uart_port *port);
 #endif /* LINUX_SERIAL_CORE_H */