mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-28 20:02:17 +00:00
![Jim Quinlan](/assets/img/avatar_default.png)
Our SoC's have always had a NS16650A UART core and older SoC's would have a compatible string of: 'compatible = ""ns16550a"' and use the 8250_of driver. Our newer SoC's have added enhancements to the base core to add support for DMA and accurate high speed baud rates and use this newer 8250_bcm7271 driver. The Device Tree node for our enhanced UARTs has a compatible string of: 'compatible = "brcm,bcm7271-uart", "ns16550a"''. With both drivers running and the link order setup so that the 8250_bcm7217 driver is initialized before the 8250_of driver, we should bind the 8250_bcm7271 driver to the enhanced UART, or for upstream kernels that don't have the 8250_bcm7271 driver, we bind to the 8250_of driver. The problem is that when both the 8250_of and 8250_bcm7271 drivers were running, occasionally the 8250_of driver would be bound to the enhanced UART instead of the 8250_bcm7271 driver. This was happening because we use SCMI based clocks which come up late in initialization and cause probe DEFER's when the two drivers get their clocks. Occasionally the SCMI clock would become ready between the 8250_bcm7271 probe and the 8250_of probe and the 8250_of driver would be bound. To fix this we decided to config only our 8250_bcm7271 driver and added "ns16665a0" to the compatible string so the driver would work on our older system. This commit has of_platform_serial_probe() check specifically for the "brcm,bcm7271-uart" and whether its companion driver is enabled. If it is the case, and the clock provider is not ready, we want to make sure that when the 8250_bcm7271.c driver returns EPROBE_DEFER, we are not getting the UART registered via 8250_of.c. Reviewed-by: Andy Shevchenko <andy.shevchenko@gmail.com> Signed-off-by: Jim Quinlan <jim2101024@gmail.com> Signed-off-by: Al Cooper <alcooperx@gmail.com> Signed-off-by: Florian Fainelli <f.fainelli@gmail.com> Link: https://lore.kernel.org/r/20210423183206.3917725-1-f.fainelli@gmail.com Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
345 lines
9 KiB
C
345 lines
9 KiB
C
// SPDX-License-Identifier: GPL-2.0+
|
|
/*
|
|
* Serial Port driver for Open Firmware platform devices
|
|
*
|
|
* Copyright (C) 2006 Arnd Bergmann <arnd@arndb.de>, IBM Corp.
|
|
*/
|
|
#include <linux/console.h>
|
|
#include <linux/module.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/serial_core.h>
|
|
#include <linux/serial_reg.h>
|
|
#include <linux/of_address.h>
|
|
#include <linux/of_irq.h>
|
|
#include <linux/of_platform.h>
|
|
#include <linux/pm_runtime.h>
|
|
#include <linux/clk.h>
|
|
#include <linux/reset.h>
|
|
|
|
#include "8250.h"
|
|
|
|
struct of_serial_info {
|
|
struct clk *clk;
|
|
struct reset_control *rst;
|
|
int type;
|
|
int line;
|
|
};
|
|
|
|
/*
|
|
* Fill a struct uart_port for a given device node
|
|
*/
|
|
static int of_platform_serial_setup(struct platform_device *ofdev,
|
|
int type, struct uart_8250_port *up,
|
|
struct of_serial_info *info)
|
|
{
|
|
struct resource resource;
|
|
struct device_node *np = ofdev->dev.of_node;
|
|
struct uart_port *port = &up->port;
|
|
u32 clk, spd, prop;
|
|
int ret, irq;
|
|
|
|
memset(port, 0, sizeof *port);
|
|
|
|
pm_runtime_enable(&ofdev->dev);
|
|
pm_runtime_get_sync(&ofdev->dev);
|
|
|
|
if (of_property_read_u32(np, "clock-frequency", &clk)) {
|
|
|
|
/* Get clk rate through clk driver if present */
|
|
info->clk = devm_clk_get(&ofdev->dev, NULL);
|
|
if (IS_ERR(info->clk)) {
|
|
ret = PTR_ERR(info->clk);
|
|
if (ret != -EPROBE_DEFER)
|
|
dev_warn(&ofdev->dev,
|
|
"failed to get clock: %d\n", ret);
|
|
goto err_pmruntime;
|
|
}
|
|
|
|
ret = clk_prepare_enable(info->clk);
|
|
if (ret < 0)
|
|
goto err_pmruntime;
|
|
|
|
clk = clk_get_rate(info->clk);
|
|
}
|
|
/* If current-speed was set, then try not to change it. */
|
|
if (of_property_read_u32(np, "current-speed", &spd) == 0)
|
|
port->custom_divisor = clk / (16 * spd);
|
|
|
|
ret = of_address_to_resource(np, 0, &resource);
|
|
if (ret) {
|
|
dev_warn(&ofdev->dev, "invalid address\n");
|
|
goto err_unprepare;
|
|
}
|
|
|
|
port->flags = UPF_SHARE_IRQ | UPF_BOOT_AUTOCONF | UPF_FIXED_PORT |
|
|
UPF_FIXED_TYPE;
|
|
spin_lock_init(&port->lock);
|
|
|
|
if (resource_type(&resource) == IORESOURCE_IO) {
|
|
port->iotype = UPIO_PORT;
|
|
port->iobase = resource.start;
|
|
} else {
|
|
port->mapbase = resource.start;
|
|
port->mapsize = resource_size(&resource);
|
|
|
|
/* Check for shifted address mapping */
|
|
if (of_property_read_u32(np, "reg-offset", &prop) == 0)
|
|
port->mapbase += prop;
|
|
|
|
port->iotype = UPIO_MEM;
|
|
if (of_property_read_u32(np, "reg-io-width", &prop) == 0) {
|
|
switch (prop) {
|
|
case 1:
|
|
port->iotype = UPIO_MEM;
|
|
break;
|
|
case 2:
|
|
port->iotype = UPIO_MEM16;
|
|
break;
|
|
case 4:
|
|
port->iotype = of_device_is_big_endian(np) ?
|
|
UPIO_MEM32BE : UPIO_MEM32;
|
|
break;
|
|
default:
|
|
dev_warn(&ofdev->dev, "unsupported reg-io-width (%d)\n",
|
|
prop);
|
|
ret = -EINVAL;
|
|
goto err_unprepare;
|
|
}
|
|
}
|
|
port->flags |= UPF_IOREMAP;
|
|
}
|
|
|
|
/* Compatibility with the deprecated pxa driver and 8250_pxa drivers. */
|
|
if (of_device_is_compatible(np, "mrvl,mmp-uart"))
|
|
port->regshift = 2;
|
|
|
|
/* Check for registers offset within the devices address range */
|
|
if (of_property_read_u32(np, "reg-shift", &prop) == 0)
|
|
port->regshift = prop;
|
|
|
|
/* Check for fifo size */
|
|
if (of_property_read_u32(np, "fifo-size", &prop) == 0)
|
|
port->fifosize = prop;
|
|
|
|
/* Check for a fixed line number */
|
|
ret = of_alias_get_id(np, "serial");
|
|
if (ret >= 0)
|
|
port->line = ret;
|
|
|
|
irq = of_irq_get(np, 0);
|
|
if (irq < 0) {
|
|
if (irq == -EPROBE_DEFER) {
|
|
ret = -EPROBE_DEFER;
|
|
goto err_unprepare;
|
|
}
|
|
/* IRQ support not mandatory */
|
|
irq = 0;
|
|
}
|
|
|
|
port->irq = irq;
|
|
|
|
info->rst = devm_reset_control_get_optional_shared(&ofdev->dev, NULL);
|
|
if (IS_ERR(info->rst)) {
|
|
ret = PTR_ERR(info->rst);
|
|
goto err_unprepare;
|
|
}
|
|
|
|
ret = reset_control_deassert(info->rst);
|
|
if (ret)
|
|
goto err_unprepare;
|
|
|
|
port->type = type;
|
|
port->uartclk = clk;
|
|
|
|
if (of_property_read_bool(np, "no-loopback-test"))
|
|
port->flags |= UPF_SKIP_TEST;
|
|
|
|
port->dev = &ofdev->dev;
|
|
port->rs485_config = serial8250_em485_config;
|
|
up->rs485_start_tx = serial8250_em485_start_tx;
|
|
up->rs485_stop_tx = serial8250_em485_stop_tx;
|
|
|
|
switch (type) {
|
|
case PORT_RT2880:
|
|
port->iotype = UPIO_AU;
|
|
break;
|
|
}
|
|
|
|
if (IS_ENABLED(CONFIG_SERIAL_8250_FSL) &&
|
|
(of_device_is_compatible(np, "fsl,ns16550") ||
|
|
of_device_is_compatible(np, "fsl,16550-FIFO64"))) {
|
|
port->handle_irq = fsl8250_handle_irq;
|
|
port->has_sysrq = IS_ENABLED(CONFIG_SERIAL_8250_CONSOLE);
|
|
}
|
|
|
|
return 0;
|
|
err_unprepare:
|
|
clk_disable_unprepare(info->clk);
|
|
err_pmruntime:
|
|
pm_runtime_put_sync(&ofdev->dev);
|
|
pm_runtime_disable(&ofdev->dev);
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* Try to register a serial port
|
|
*/
|
|
static int of_platform_serial_probe(struct platform_device *ofdev)
|
|
{
|
|
struct of_serial_info *info;
|
|
struct uart_8250_port port8250;
|
|
unsigned int port_type;
|
|
u32 tx_threshold;
|
|
int ret;
|
|
|
|
if (IS_ENABLED(CONFIG_SERIAL_8250_BCM7271) &&
|
|
of_device_is_compatible(ofdev->dev.of_node, "brcm,bcm7271-uart"))
|
|
return -ENODEV;
|
|
|
|
port_type = (unsigned long)of_device_get_match_data(&ofdev->dev);
|
|
if (port_type == PORT_UNKNOWN)
|
|
return -EINVAL;
|
|
|
|
if (of_property_read_bool(ofdev->dev.of_node, "used-by-rtas"))
|
|
return -EBUSY;
|
|
|
|
info = kzalloc(sizeof(*info), GFP_KERNEL);
|
|
if (info == NULL)
|
|
return -ENOMEM;
|
|
|
|
memset(&port8250, 0, sizeof(port8250));
|
|
ret = of_platform_serial_setup(ofdev, port_type, &port8250, info);
|
|
if (ret)
|
|
goto err_free;
|
|
|
|
if (port8250.port.fifosize)
|
|
port8250.capabilities = UART_CAP_FIFO;
|
|
|
|
/* Check for TX FIFO threshold & set tx_loadsz */
|
|
if ((of_property_read_u32(ofdev->dev.of_node, "tx-threshold",
|
|
&tx_threshold) == 0) &&
|
|
(tx_threshold < port8250.port.fifosize))
|
|
port8250.tx_loadsz = port8250.port.fifosize - tx_threshold;
|
|
|
|
if (of_property_read_bool(ofdev->dev.of_node, "auto-flow-control"))
|
|
port8250.capabilities |= UART_CAP_AFE;
|
|
|
|
if (of_property_read_u32(ofdev->dev.of_node,
|
|
"overrun-throttle-ms",
|
|
&port8250.overrun_backoff_time_ms) != 0)
|
|
port8250.overrun_backoff_time_ms = 0;
|
|
|
|
ret = serial8250_register_8250_port(&port8250);
|
|
if (ret < 0)
|
|
goto err_dispose;
|
|
|
|
info->type = port_type;
|
|
info->line = ret;
|
|
platform_set_drvdata(ofdev, info);
|
|
return 0;
|
|
err_dispose:
|
|
irq_dispose_mapping(port8250.port.irq);
|
|
pm_runtime_put_sync(&ofdev->dev);
|
|
pm_runtime_disable(&ofdev->dev);
|
|
clk_disable_unprepare(info->clk);
|
|
err_free:
|
|
kfree(info);
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* Release a line
|
|
*/
|
|
static int of_platform_serial_remove(struct platform_device *ofdev)
|
|
{
|
|
struct of_serial_info *info = platform_get_drvdata(ofdev);
|
|
|
|
serial8250_unregister_port(info->line);
|
|
|
|
reset_control_assert(info->rst);
|
|
pm_runtime_put_sync(&ofdev->dev);
|
|
pm_runtime_disable(&ofdev->dev);
|
|
clk_disable_unprepare(info->clk);
|
|
kfree(info);
|
|
return 0;
|
|
}
|
|
|
|
#ifdef CONFIG_PM_SLEEP
|
|
static int of_serial_suspend(struct device *dev)
|
|
{
|
|
struct of_serial_info *info = dev_get_drvdata(dev);
|
|
struct uart_8250_port *port8250 = serial8250_get_port(info->line);
|
|
struct uart_port *port = &port8250->port;
|
|
|
|
serial8250_suspend_port(info->line);
|
|
|
|
if (!uart_console(port) || console_suspend_enabled) {
|
|
pm_runtime_put_sync(dev);
|
|
clk_disable_unprepare(info->clk);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int of_serial_resume(struct device *dev)
|
|
{
|
|
struct of_serial_info *info = dev_get_drvdata(dev);
|
|
struct uart_8250_port *port8250 = serial8250_get_port(info->line);
|
|
struct uart_port *port = &port8250->port;
|
|
|
|
if (!uart_console(port) || console_suspend_enabled) {
|
|
pm_runtime_get_sync(dev);
|
|
clk_prepare_enable(info->clk);
|
|
}
|
|
|
|
serial8250_resume_port(info->line);
|
|
|
|
return 0;
|
|
}
|
|
#endif
|
|
static SIMPLE_DEV_PM_OPS(of_serial_pm_ops, of_serial_suspend, of_serial_resume);
|
|
|
|
/*
|
|
* A few common types, add more as needed.
|
|
*/
|
|
static const struct of_device_id of_platform_serial_table[] = {
|
|
{ .compatible = "ns8250", .data = (void *)PORT_8250, },
|
|
{ .compatible = "ns16450", .data = (void *)PORT_16450, },
|
|
{ .compatible = "ns16550a", .data = (void *)PORT_16550A, },
|
|
{ .compatible = "ns16550", .data = (void *)PORT_16550, },
|
|
{ .compatible = "ns16750", .data = (void *)PORT_16750, },
|
|
{ .compatible = "ns16850", .data = (void *)PORT_16850, },
|
|
{ .compatible = "nxp,lpc3220-uart", .data = (void *)PORT_LPC3220, },
|
|
{ .compatible = "ralink,rt2880-uart", .data = (void *)PORT_RT2880, },
|
|
{ .compatible = "intel,xscale-uart", .data = (void *)PORT_XSCALE, },
|
|
{ .compatible = "altr,16550-FIFO32",
|
|
.data = (void *)PORT_ALTR_16550_F32, },
|
|
{ .compatible = "altr,16550-FIFO64",
|
|
.data = (void *)PORT_ALTR_16550_F64, },
|
|
{ .compatible = "altr,16550-FIFO128",
|
|
.data = (void *)PORT_ALTR_16550_F128, },
|
|
{ .compatible = "mediatek,mtk-btif",
|
|
.data = (void *)PORT_MTK_BTIF, },
|
|
{ .compatible = "mrvl,mmp-uart",
|
|
.data = (void *)PORT_XSCALE, },
|
|
{ .compatible = "ti,da830-uart", .data = (void *)PORT_DA830, },
|
|
{ .compatible = "nuvoton,wpcm450-uart", .data = (void *)PORT_NPCM, },
|
|
{ .compatible = "nuvoton,npcm750-uart", .data = (void *)PORT_NPCM, },
|
|
{ /* end of list */ },
|
|
};
|
|
MODULE_DEVICE_TABLE(of, of_platform_serial_table);
|
|
|
|
static struct platform_driver of_platform_serial_driver = {
|
|
.driver = {
|
|
.name = "of_serial",
|
|
.of_match_table = of_platform_serial_table,
|
|
.pm = &of_serial_pm_ops,
|
|
},
|
|
.probe = of_platform_serial_probe,
|
|
.remove = of_platform_serial_remove,
|
|
};
|
|
|
|
module_platform_driver(of_platform_serial_driver);
|
|
|
|
MODULE_AUTHOR("Arnd Bergmann <arnd@arndb.de>");
|
|
MODULE_LICENSE("GPL");
|
|
MODULE_DESCRIPTION("Serial Port driver for Open Firmware platform devices");
|