2017-11-07 01:11:51 +08:00
|
|
|
// SPDX-License-Identifier: GPL-2.0+
|
2016-02-17 02:14:53 +08:00
|
|
|
/*
|
|
|
|
|
* ***************************************************************************
|
2016-03-14 07:48:52 +08:00
|
|
|
* Marvell Armada-3700 Serial Driver
|
|
|
|
|
* Author: Wilson Ding <dingwei@marvell.com>
|
2016-02-17 02:14:53 +08:00
|
|
|
* Copyright (C) 2015 Marvell International Ltd.
|
|
|
|
|
* ***************************************************************************
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#include <linux/clk.h>
|
serial: mvebu-uart: implement UART clock driver for configuring UART base clock
Implement a new device driver for controlling UART clocks on Marvell
Armada 3700 SoC. This device driver is loaded for devices which match
the compatible string "marvell,armada-3700-uart-clock".
There are more pitfalls related to UART clocks:
- both UARTs use same parent clock source (which can be xtal or one of
the TBG clocks),
- if a TBG clock is used as the parent clock, there are two additional
divisors that can both be configured to divide the rate by 1, 2, ... 6,
but these divisors are again shared between the two UART controllers
on the SOC,
- the configuration of the parent clock source and divisors is done in
the address space of the first UART controller, UART1. Clocks can be
gated separately for UART1 and UART2, but this setting also lives in
the address space of UART1,
- Marvell's Functional Specification for Armada 3720 document has the
clock gating bits swapped, so the one described to gate UART1 clock
actually gates UART2 and vice versa,
- each UART has it's own "special divisor", and this uses the parent
clock described above. These divisors are configure in each UART's
address space separately.
Thus the driver for UART2 controller needs to have access to UART1
address space, since UART1 address space contains some bits exclusive
for UART2 and also some bits which are shared between UART1 and UART2.
Also, during boot, when early console is active on one of the UARTs,
and we want to switch parent clock from xtal (default) to TBG (to be
more flexible with baudrates), the driver changing UART clocks also
needs to be able to change the "special divisor", so that the baudrate
of earlycon is not changed when swtiching to normal console. Thus the
clock driver also needs to be able to access UART2 register space,
for UART2's "special divisor".
For these reasons, this new UART clock driver does not use
ioremap_resource(), but only ioremap() to prevent resource conflicts
between UART clock driver and UART driver.
We need to share only two 32-bit registers between the UART driver and
the UART clock driver:
- UART Clock Control
- UART 2 Baud Rate Divisor
Access to these two registers are protected by one spinlock to prevent
any conflicts. Access is required only during probing, when changing
baudrate or during suspend/resume.
Hardware can be configured to use one of following clocks as UART parent
clock: TBG-A-P, TBG-B-P, TBG-A-S, TBG-B-S, xtal. Not every clock is
usable for higher buadrates. Any subset can be specified in the
device-tree and the driver will choose the best one which also still
supports the mandatory baudrate of 9600 Bd. For smooth boot log output
it is needed to specify clock used by early console, otherwise garbage
would be printed on UART during probe of UART clock driver and
transitioning from early console to normal console.
We are implementing this to be able to configure TBG clock as UART
parent clock, which is required to be able to achieve higher baudrates
than 230400 Bd. We achieve this by referencing this new UART clock
device node in UART's device node. UART clock device driver
automatically chooses the best clock source for UART driver.
Until now, UART's device-tree node needed to reference one of the static
clocks (xtal or one of the TBGs) as parent clock in the `clocks`
phandle - the parent clock which was configured before booting the
kernel. If bootloader changed UART's parent clock, it needed to change
the `clocks` phandle in DTB correspondingly before booting.
From now on both the old mechanism (xtal or TBG referenced as parent
clock in `clocks` phandle) and the new one (UART clock referenced in the
`clocks` phandle) are supported, to provide full backward compatibility
with existing DTS files, full backward compatibility with existing boot
loaders, and to provide new features (runtime clock configuration to
allow higher baudrates than 230400 Bd). New features are available only
with new DTS files.
There was also a discussion about how the UART node and the
clock-controller node could be wrapped together in a new binding [1, 2].
As explained there, this is not possible if we want to keep backwards
compatibility with existing bootloaders, and thus we are doing this by
putting the UART clock-controller node inside the UART1 node.
[1] https://lore.kernel.org/linux-serial/20220120000651.in7s6nazif5qjkme@pali/
[2] https://lore.kernel.org/linux-serial/20220125204006.A6D09C340E0@smtp.kernel.org/
Reviewed-by: Marek Behún <kabel@kernel.org>
Reviewed-by: Stephen Boyd <sboyd@kernel.org>
Signed-off-by: Pali Rohár <pali@kernel.org>
Signed-off-by: Marek Behún <kabel@kernel.org>
Link: https://lore.kernel.org/r/20220219152818.4319-4-kabel@kernel.org
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2022-02-19 23:28:15 +08:00
|
|
|
#include <linux/clk-provider.h>
|
2016-02-17 02:14:53 +08:00
|
|
|
#include <linux/console.h>
|
|
|
|
|
#include <linux/delay.h>
|
|
|
|
|
#include <linux/device.h>
|
|
|
|
|
#include <linux/init.h>
|
|
|
|
|
#include <linux/io.h>
|
|
|
|
|
#include <linux/iopoll.h>
|
serial: mvebu-uart: implement UART clock driver for configuring UART base clock
Implement a new device driver for controlling UART clocks on Marvell
Armada 3700 SoC. This device driver is loaded for devices which match
the compatible string "marvell,armada-3700-uart-clock".
There are more pitfalls related to UART clocks:
- both UARTs use same parent clock source (which can be xtal or one of
the TBG clocks),
- if a TBG clock is used as the parent clock, there are two additional
divisors that can both be configured to divide the rate by 1, 2, ... 6,
but these divisors are again shared between the two UART controllers
on the SOC,
- the configuration of the parent clock source and divisors is done in
the address space of the first UART controller, UART1. Clocks can be
gated separately for UART1 and UART2, but this setting also lives in
the address space of UART1,
- Marvell's Functional Specification for Armada 3720 document has the
clock gating bits swapped, so the one described to gate UART1 clock
actually gates UART2 and vice versa,
- each UART has it's own "special divisor", and this uses the parent
clock described above. These divisors are configure in each UART's
address space separately.
Thus the driver for UART2 controller needs to have access to UART1
address space, since UART1 address space contains some bits exclusive
for UART2 and also some bits which are shared between UART1 and UART2.
Also, during boot, when early console is active on one of the UARTs,
and we want to switch parent clock from xtal (default) to TBG (to be
more flexible with baudrates), the driver changing UART clocks also
needs to be able to change the "special divisor", so that the baudrate
of earlycon is not changed when swtiching to normal console. Thus the
clock driver also needs to be able to access UART2 register space,
for UART2's "special divisor".
For these reasons, this new UART clock driver does not use
ioremap_resource(), but only ioremap() to prevent resource conflicts
between UART clock driver and UART driver.
We need to share only two 32-bit registers between the UART driver and
the UART clock driver:
- UART Clock Control
- UART 2 Baud Rate Divisor
Access to these two registers are protected by one spinlock to prevent
any conflicts. Access is required only during probing, when changing
baudrate or during suspend/resume.
Hardware can be configured to use one of following clocks as UART parent
clock: TBG-A-P, TBG-B-P, TBG-A-S, TBG-B-S, xtal. Not every clock is
usable for higher buadrates. Any subset can be specified in the
device-tree and the driver will choose the best one which also still
supports the mandatory baudrate of 9600 Bd. For smooth boot log output
it is needed to specify clock used by early console, otherwise garbage
would be printed on UART during probe of UART clock driver and
transitioning from early console to normal console.
We are implementing this to be able to configure TBG clock as UART
parent clock, which is required to be able to achieve higher baudrates
than 230400 Bd. We achieve this by referencing this new UART clock
device node in UART's device node. UART clock device driver
automatically chooses the best clock source for UART driver.
Until now, UART's device-tree node needed to reference one of the static
clocks (xtal or one of the TBGs) as parent clock in the `clocks`
phandle - the parent clock which was configured before booting the
kernel. If bootloader changed UART's parent clock, it needed to change
the `clocks` phandle in DTB correspondingly before booting.
From now on both the old mechanism (xtal or TBG referenced as parent
clock in `clocks` phandle) and the new one (UART clock referenced in the
`clocks` phandle) are supported, to provide full backward compatibility
with existing DTS files, full backward compatibility with existing boot
loaders, and to provide new features (runtime clock configuration to
allow higher baudrates than 230400 Bd). New features are available only
with new DTS files.
There was also a discussion about how the UART node and the
clock-controller node could be wrapped together in a new binding [1, 2].
As explained there, this is not possible if we want to keep backwards
compatibility with existing bootloaders, and thus we are doing this by
putting the UART clock-controller node inside the UART1 node.
[1] https://lore.kernel.org/linux-serial/20220120000651.in7s6nazif5qjkme@pali/
[2] https://lore.kernel.org/linux-serial/20220125204006.A6D09C340E0@smtp.kernel.org/
Reviewed-by: Marek Behún <kabel@kernel.org>
Reviewed-by: Stephen Boyd <sboyd@kernel.org>
Signed-off-by: Pali Rohár <pali@kernel.org>
Signed-off-by: Marek Behún <kabel@kernel.org>
Link: https://lore.kernel.org/r/20220219152818.4319-4-kabel@kernel.org
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2022-02-19 23:28:15 +08:00
|
|
|
#include <linux/math64.h>
|
2016-02-17 02:14:53 +08:00
|
|
|
#include <linux/of.h>
|
|
|
|
|
#include <linux/of_address.h>
|
|
|
|
|
#include <linux/of_device.h>
|
|
|
|
|
#include <linux/of_irq.h>
|
|
|
|
|
#include <linux/of_platform.h>
|
|
|
|
|
#include <linux/platform_device.h>
|
|
|
|
|
#include <linux/serial.h>
|
|
|
|
|
#include <linux/serial_core.h>
|
|
|
|
|
#include <linux/slab.h>
|
|
|
|
|
#include <linux/tty.h>
|
|
|
|
|
#include <linux/tty_flip.h>
|
|
|
|
|
|
|
|
|
|
/* Register Map */
|
2017-10-13 17:01:49 +08:00
|
|
|
#define UART_STD_RBR 0x00
|
2017-10-13 17:01:56 +08:00
|
|
|
#define UART_EXT_RBR 0x18
|
2016-02-17 02:14:53 +08:00
|
|
|
|
2017-10-13 17:01:49 +08:00
|
|
|
#define UART_STD_TSH 0x04
|
2017-10-13 17:01:56 +08:00
|
|
|
#define UART_EXT_TSH 0x1C
|
2016-02-17 02:14:53 +08:00
|
|
|
|
2017-10-13 17:01:49 +08:00
|
|
|
#define UART_STD_CTRL1 0x08
|
2017-10-13 17:01:56 +08:00
|
|
|
#define UART_EXT_CTRL1 0x04
|
2016-02-17 02:14:53 +08:00
|
|
|
#define CTRL_SOFT_RST BIT(31)
|
|
|
|
|
#define CTRL_TXFIFO_RST BIT(15)
|
|
|
|
|
#define CTRL_RXFIFO_RST BIT(14)
|
|
|
|
|
#define CTRL_SND_BRK_SEQ BIT(11)
|
|
|
|
|
#define CTRL_BRK_DET_INT BIT(3)
|
|
|
|
|
#define CTRL_FRM_ERR_INT BIT(2)
|
|
|
|
|
#define CTRL_PAR_ERR_INT BIT(1)
|
|
|
|
|
#define CTRL_OVR_ERR_INT BIT(0)
|
2017-10-13 17:01:49 +08:00
|
|
|
#define CTRL_BRK_INT (CTRL_BRK_DET_INT | CTRL_FRM_ERR_INT | \
|
|
|
|
|
CTRL_PAR_ERR_INT | CTRL_OVR_ERR_INT)
|
2016-02-17 02:14:53 +08:00
|
|
|
|
2017-10-13 17:01:49 +08:00
|
|
|
#define UART_STD_CTRL2 UART_STD_CTRL1
|
2017-10-13 17:01:56 +08:00
|
|
|
#define UART_EXT_CTRL2 0x20
|
2017-10-13 17:01:49 +08:00
|
|
|
#define CTRL_STD_TX_RDY_INT BIT(5)
|
2017-10-13 17:01:56 +08:00
|
|
|
#define CTRL_EXT_TX_RDY_INT BIT(6)
|
2017-10-13 17:01:49 +08:00
|
|
|
#define CTRL_STD_RX_RDY_INT BIT(4)
|
2017-10-13 17:01:56 +08:00
|
|
|
#define CTRL_EXT_RX_RDY_INT BIT(5)
|
2017-10-13 17:01:49 +08:00
|
|
|
|
|
|
|
|
#define UART_STAT 0x0C
|
2016-02-17 02:14:53 +08:00
|
|
|
#define STAT_TX_FIFO_EMP BIT(13)
|
|
|
|
|
#define STAT_TX_FIFO_FUL BIT(11)
|
|
|
|
|
#define STAT_TX_EMP BIT(6)
|
2017-10-13 17:01:49 +08:00
|
|
|
#define STAT_STD_TX_RDY BIT(5)
|
2017-10-13 17:01:56 +08:00
|
|
|
#define STAT_EXT_TX_RDY BIT(15)
|
2017-10-13 17:01:49 +08:00
|
|
|
#define STAT_STD_RX_RDY BIT(4)
|
2017-10-13 17:01:56 +08:00
|
|
|
#define STAT_EXT_RX_RDY BIT(14)
|
2016-02-17 02:14:53 +08:00
|
|
|
#define STAT_BRK_DET BIT(3)
|
|
|
|
|
#define STAT_FRM_ERR BIT(2)
|
|
|
|
|
#define STAT_PAR_ERR BIT(1)
|
|
|
|
|
#define STAT_OVR_ERR BIT(0)
|
2018-02-23 22:14:51 +08:00
|
|
|
#define STAT_BRK_ERR (STAT_BRK_DET | STAT_FRM_ERR \
|
2016-02-17 02:14:53 +08:00
|
|
|
| STAT_PAR_ERR | STAT_OVR_ERR)
|
|
|
|
|
|
serial: mvebu-uart: implement UART clock driver for configuring UART base clock
Implement a new device driver for controlling UART clocks on Marvell
Armada 3700 SoC. This device driver is loaded for devices which match
the compatible string "marvell,armada-3700-uart-clock".
There are more pitfalls related to UART clocks:
- both UARTs use same parent clock source (which can be xtal or one of
the TBG clocks),
- if a TBG clock is used as the parent clock, there are two additional
divisors that can both be configured to divide the rate by 1, 2, ... 6,
but these divisors are again shared between the two UART controllers
on the SOC,
- the configuration of the parent clock source and divisors is done in
the address space of the first UART controller, UART1. Clocks can be
gated separately for UART1 and UART2, but this setting also lives in
the address space of UART1,
- Marvell's Functional Specification for Armada 3720 document has the
clock gating bits swapped, so the one described to gate UART1 clock
actually gates UART2 and vice versa,
- each UART has it's own "special divisor", and this uses the parent
clock described above. These divisors are configure in each UART's
address space separately.
Thus the driver for UART2 controller needs to have access to UART1
address space, since UART1 address space contains some bits exclusive
for UART2 and also some bits which are shared between UART1 and UART2.
Also, during boot, when early console is active on one of the UARTs,
and we want to switch parent clock from xtal (default) to TBG (to be
more flexible with baudrates), the driver changing UART clocks also
needs to be able to change the "special divisor", so that the baudrate
of earlycon is not changed when swtiching to normal console. Thus the
clock driver also needs to be able to access UART2 register space,
for UART2's "special divisor".
For these reasons, this new UART clock driver does not use
ioremap_resource(), but only ioremap() to prevent resource conflicts
between UART clock driver and UART driver.
We need to share only two 32-bit registers between the UART driver and
the UART clock driver:
- UART Clock Control
- UART 2 Baud Rate Divisor
Access to these two registers are protected by one spinlock to prevent
any conflicts. Access is required only during probing, when changing
baudrate or during suspend/resume.
Hardware can be configured to use one of following clocks as UART parent
clock: TBG-A-P, TBG-B-P, TBG-A-S, TBG-B-S, xtal. Not every clock is
usable for higher buadrates. Any subset can be specified in the
device-tree and the driver will choose the best one which also still
supports the mandatory baudrate of 9600 Bd. For smooth boot log output
it is needed to specify clock used by early console, otherwise garbage
would be printed on UART during probe of UART clock driver and
transitioning from early console to normal console.
We are implementing this to be able to configure TBG clock as UART
parent clock, which is required to be able to achieve higher baudrates
than 230400 Bd. We achieve this by referencing this new UART clock
device node in UART's device node. UART clock device driver
automatically chooses the best clock source for UART driver.
Until now, UART's device-tree node needed to reference one of the static
clocks (xtal or one of the TBGs) as parent clock in the `clocks`
phandle - the parent clock which was configured before booting the
kernel. If bootloader changed UART's parent clock, it needed to change
the `clocks` phandle in DTB correspondingly before booting.
From now on both the old mechanism (xtal or TBG referenced as parent
clock in `clocks` phandle) and the new one (UART clock referenced in the
`clocks` phandle) are supported, to provide full backward compatibility
with existing DTS files, full backward compatibility with existing boot
loaders, and to provide new features (runtime clock configuration to
allow higher baudrates than 230400 Bd). New features are available only
with new DTS files.
There was also a discussion about how the UART node and the
clock-controller node could be wrapped together in a new binding [1, 2].
As explained there, this is not possible if we want to keep backwards
compatibility with existing bootloaders, and thus we are doing this by
putting the UART clock-controller node inside the UART1 node.
[1] https://lore.kernel.org/linux-serial/20220120000651.in7s6nazif5qjkme@pali/
[2] https://lore.kernel.org/linux-serial/20220125204006.A6D09C340E0@smtp.kernel.org/
Reviewed-by: Marek Behún <kabel@kernel.org>
Reviewed-by: Stephen Boyd <sboyd@kernel.org>
Signed-off-by: Pali Rohár <pali@kernel.org>
Signed-off-by: Marek Behún <kabel@kernel.org>
Link: https://lore.kernel.org/r/20220219152818.4319-4-kabel@kernel.org
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2022-02-19 23:28:15 +08:00
|
|
|
/*
|
|
|
|
|
* Marvell Armada 3700 Functional Specifications describes that bit 21 of UART
|
|
|
|
|
* Clock Control register controls UART1 and bit 20 controls UART2. But in
|
|
|
|
|
* reality bit 21 controls UART2 and bit 20 controls UART1. This seems to be an
|
|
|
|
|
* error in Marvell's documentation. Hence following CLK_DIS macros are swapped.
|
|
|
|
|
*/
|
|
|
|
|
|
2016-02-17 02:14:53 +08:00
|
|
|
#define UART_BRDV 0x10
|
serial: mvebu-uart: implement UART clock driver for configuring UART base clock
Implement a new device driver for controlling UART clocks on Marvell
Armada 3700 SoC. This device driver is loaded for devices which match
the compatible string "marvell,armada-3700-uart-clock".
There are more pitfalls related to UART clocks:
- both UARTs use same parent clock source (which can be xtal or one of
the TBG clocks),
- if a TBG clock is used as the parent clock, there are two additional
divisors that can both be configured to divide the rate by 1, 2, ... 6,
but these divisors are again shared between the two UART controllers
on the SOC,
- the configuration of the parent clock source and divisors is done in
the address space of the first UART controller, UART1. Clocks can be
gated separately for UART1 and UART2, but this setting also lives in
the address space of UART1,
- Marvell's Functional Specification for Armada 3720 document has the
clock gating bits swapped, so the one described to gate UART1 clock
actually gates UART2 and vice versa,
- each UART has it's own "special divisor", and this uses the parent
clock described above. These divisors are configure in each UART's
address space separately.
Thus the driver for UART2 controller needs to have access to UART1
address space, since UART1 address space contains some bits exclusive
for UART2 and also some bits which are shared between UART1 and UART2.
Also, during boot, when early console is active on one of the UARTs,
and we want to switch parent clock from xtal (default) to TBG (to be
more flexible with baudrates), the driver changing UART clocks also
needs to be able to change the "special divisor", so that the baudrate
of earlycon is not changed when swtiching to normal console. Thus the
clock driver also needs to be able to access UART2 register space,
for UART2's "special divisor".
For these reasons, this new UART clock driver does not use
ioremap_resource(), but only ioremap() to prevent resource conflicts
between UART clock driver and UART driver.
We need to share only two 32-bit registers between the UART driver and
the UART clock driver:
- UART Clock Control
- UART 2 Baud Rate Divisor
Access to these two registers are protected by one spinlock to prevent
any conflicts. Access is required only during probing, when changing
baudrate or during suspend/resume.
Hardware can be configured to use one of following clocks as UART parent
clock: TBG-A-P, TBG-B-P, TBG-A-S, TBG-B-S, xtal. Not every clock is
usable for higher buadrates. Any subset can be specified in the
device-tree and the driver will choose the best one which also still
supports the mandatory baudrate of 9600 Bd. For smooth boot log output
it is needed to specify clock used by early console, otherwise garbage
would be printed on UART during probe of UART clock driver and
transitioning from early console to normal console.
We are implementing this to be able to configure TBG clock as UART
parent clock, which is required to be able to achieve higher baudrates
than 230400 Bd. We achieve this by referencing this new UART clock
device node in UART's device node. UART clock device driver
automatically chooses the best clock source for UART driver.
Until now, UART's device-tree node needed to reference one of the static
clocks (xtal or one of the TBGs) as parent clock in the `clocks`
phandle - the parent clock which was configured before booting the
kernel. If bootloader changed UART's parent clock, it needed to change
the `clocks` phandle in DTB correspondingly before booting.
From now on both the old mechanism (xtal or TBG referenced as parent
clock in `clocks` phandle) and the new one (UART clock referenced in the
`clocks` phandle) are supported, to provide full backward compatibility
with existing DTS files, full backward compatibility with existing boot
loaders, and to provide new features (runtime clock configuration to
allow higher baudrates than 230400 Bd). New features are available only
with new DTS files.
There was also a discussion about how the UART node and the
clock-controller node could be wrapped together in a new binding [1, 2].
As explained there, this is not possible if we want to keep backwards
compatibility with existing bootloaders, and thus we are doing this by
putting the UART clock-controller node inside the UART1 node.
[1] https://lore.kernel.org/linux-serial/20220120000651.in7s6nazif5qjkme@pali/
[2] https://lore.kernel.org/linux-serial/20220125204006.A6D09C340E0@smtp.kernel.org/
Reviewed-by: Marek Behún <kabel@kernel.org>
Reviewed-by: Stephen Boyd <sboyd@kernel.org>
Signed-off-by: Pali Rohár <pali@kernel.org>
Signed-off-by: Marek Behún <kabel@kernel.org>
Link: https://lore.kernel.org/r/20220219152818.4319-4-kabel@kernel.org
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2022-02-19 23:28:15 +08:00
|
|
|
/* These bits are located in UART1 address space and control UART2 */
|
|
|
|
|
#define UART2_CLK_DIS BIT(21)
|
|
|
|
|
/* These bits are located in UART1 address space and control UART1 */
|
|
|
|
|
#define UART1_CLK_DIS BIT(20)
|
|
|
|
|
/* These bits are located in UART1 address space and control both UARTs */
|
|
|
|
|
#define CLK_NO_XTAL BIT(19)
|
|
|
|
|
#define CLK_TBG_DIV1_SHIFT 15
|
|
|
|
|
#define CLK_TBG_DIV1_MASK 0x7
|
|
|
|
|
#define CLK_TBG_DIV1_MAX 6
|
|
|
|
|
#define CLK_TBG_DIV2_SHIFT 12
|
|
|
|
|
#define CLK_TBG_DIV2_MASK 0x7
|
|
|
|
|
#define CLK_TBG_DIV2_MAX 6
|
|
|
|
|
#define CLK_TBG_SEL_SHIFT 10
|
|
|
|
|
#define CLK_TBG_SEL_MASK 0x3
|
|
|
|
|
/* These bits are located in both UARTs address space */
|
2017-10-13 17:01:51 +08:00
|
|
|
#define BRDV_BAUD_MASK 0x3FF
|
serial: mvebu-uart: implement UART clock driver for configuring UART base clock
Implement a new device driver for controlling UART clocks on Marvell
Armada 3700 SoC. This device driver is loaded for devices which match
the compatible string "marvell,armada-3700-uart-clock".
There are more pitfalls related to UART clocks:
- both UARTs use same parent clock source (which can be xtal or one of
the TBG clocks),
- if a TBG clock is used as the parent clock, there are two additional
divisors that can both be configured to divide the rate by 1, 2, ... 6,
but these divisors are again shared between the two UART controllers
on the SOC,
- the configuration of the parent clock source and divisors is done in
the address space of the first UART controller, UART1. Clocks can be
gated separately for UART1 and UART2, but this setting also lives in
the address space of UART1,
- Marvell's Functional Specification for Armada 3720 document has the
clock gating bits swapped, so the one described to gate UART1 clock
actually gates UART2 and vice versa,
- each UART has it's own "special divisor", and this uses the parent
clock described above. These divisors are configure in each UART's
address space separately.
Thus the driver for UART2 controller needs to have access to UART1
address space, since UART1 address space contains some bits exclusive
for UART2 and also some bits which are shared between UART1 and UART2.
Also, during boot, when early console is active on one of the UARTs,
and we want to switch parent clock from xtal (default) to TBG (to be
more flexible with baudrates), the driver changing UART clocks also
needs to be able to change the "special divisor", so that the baudrate
of earlycon is not changed when swtiching to normal console. Thus the
clock driver also needs to be able to access UART2 register space,
for UART2's "special divisor".
For these reasons, this new UART clock driver does not use
ioremap_resource(), but only ioremap() to prevent resource conflicts
between UART clock driver and UART driver.
We need to share only two 32-bit registers between the UART driver and
the UART clock driver:
- UART Clock Control
- UART 2 Baud Rate Divisor
Access to these two registers are protected by one spinlock to prevent
any conflicts. Access is required only during probing, when changing
baudrate or during suspend/resume.
Hardware can be configured to use one of following clocks as UART parent
clock: TBG-A-P, TBG-B-P, TBG-A-S, TBG-B-S, xtal. Not every clock is
usable for higher buadrates. Any subset can be specified in the
device-tree and the driver will choose the best one which also still
supports the mandatory baudrate of 9600 Bd. For smooth boot log output
it is needed to specify clock used by early console, otherwise garbage
would be printed on UART during probe of UART clock driver and
transitioning from early console to normal console.
We are implementing this to be able to configure TBG clock as UART
parent clock, which is required to be able to achieve higher baudrates
than 230400 Bd. We achieve this by referencing this new UART clock
device node in UART's device node. UART clock device driver
automatically chooses the best clock source for UART driver.
Until now, UART's device-tree node needed to reference one of the static
clocks (xtal or one of the TBGs) as parent clock in the `clocks`
phandle - the parent clock which was configured before booting the
kernel. If bootloader changed UART's parent clock, it needed to change
the `clocks` phandle in DTB correspondingly before booting.
From now on both the old mechanism (xtal or TBG referenced as parent
clock in `clocks` phandle) and the new one (UART clock referenced in the
`clocks` phandle) are supported, to provide full backward compatibility
with existing DTS files, full backward compatibility with existing boot
loaders, and to provide new features (runtime clock configuration to
allow higher baudrates than 230400 Bd). New features are available only
with new DTS files.
There was also a discussion about how the UART node and the
clock-controller node could be wrapped together in a new binding [1, 2].
As explained there, this is not possible if we want to keep backwards
compatibility with existing bootloaders, and thus we are doing this by
putting the UART clock-controller node inside the UART1 node.
[1] https://lore.kernel.org/linux-serial/20220120000651.in7s6nazif5qjkme@pali/
[2] https://lore.kernel.org/linux-serial/20220125204006.A6D09C340E0@smtp.kernel.org/
Reviewed-by: Marek Behún <kabel@kernel.org>
Reviewed-by: Stephen Boyd <sboyd@kernel.org>
Signed-off-by: Pali Rohár <pali@kernel.org>
Signed-off-by: Marek Behún <kabel@kernel.org>
Link: https://lore.kernel.org/r/20220219152818.4319-4-kabel@kernel.org
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2022-02-19 23:28:15 +08:00
|
|
|
#define BRDV_BAUD_MAX BRDV_BAUD_MASK
|
2016-02-17 02:14:53 +08:00
|
|
|
|
2018-04-21 22:07:33 +08:00
|
|
|
#define UART_OSAMP 0x14
|
2018-11-23 23:45:29 +08:00
|
|
|
#define OSAMP_DEFAULT_DIVISOR 16
|
2018-11-23 23:45:30 +08:00
|
|
|
#define OSAMP_DIVISORS_MASK 0x3F3F3F3F
|
2022-02-19 23:28:17 +08:00
|
|
|
#define OSAMP_MAX_DIVISOR 63
|
2018-04-21 22:07:33 +08:00
|
|
|
|
2017-10-13 17:01:55 +08:00
|
|
|
#define MVEBU_NR_UARTS 2
|
2016-02-17 02:14:53 +08:00
|
|
|
|
|
|
|
|
#define MVEBU_UART_TYPE "mvebu-uart"
|
2017-10-13 17:01:47 +08:00
|
|
|
#define DRIVER_NAME "mvebu_serial"
|
2016-02-17 02:14:53 +08:00
|
|
|
|
2017-10-13 17:01:54 +08:00
|
|
|
enum {
|
|
|
|
|
/* Either there is only one summed IRQ... */
|
|
|
|
|
UART_IRQ_SUM = 0,
|
|
|
|
|
/* ...or there are two separate IRQ for RX and TX */
|
|
|
|
|
UART_RX_IRQ = 0,
|
|
|
|
|
UART_TX_IRQ,
|
|
|
|
|
UART_IRQ_COUNT
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/* Diverging register offsets */
|
2017-10-13 17:01:49 +08:00
|
|
|
struct uart_regs_layout {
|
|
|
|
|
unsigned int rbr;
|
|
|
|
|
unsigned int tsh;
|
|
|
|
|
unsigned int ctrl;
|
|
|
|
|
unsigned int intr;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/* Diverging flags */
|
|
|
|
|
struct uart_flags {
|
|
|
|
|
unsigned int ctrl_tx_rdy_int;
|
|
|
|
|
unsigned int ctrl_rx_rdy_int;
|
|
|
|
|
unsigned int stat_tx_rdy;
|
|
|
|
|
unsigned int stat_rx_rdy;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/* Driver data, a structure for each UART port */
|
|
|
|
|
struct mvebu_uart_driver_data {
|
|
|
|
|
bool is_ext;
|
|
|
|
|
struct uart_regs_layout regs;
|
|
|
|
|
struct uart_flags flags;
|
|
|
|
|
};
|
2016-02-17 02:14:53 +08:00
|
|
|
|
2018-04-21 22:07:33 +08:00
|
|
|
/* Saved registers during suspend */
|
|
|
|
|
struct mvebu_uart_pm_regs {
|
|
|
|
|
unsigned int rbr;
|
|
|
|
|
unsigned int tsh;
|
|
|
|
|
unsigned int ctrl;
|
|
|
|
|
unsigned int intr;
|
|
|
|
|
unsigned int stat;
|
|
|
|
|
unsigned int brdv;
|
|
|
|
|
unsigned int osamp;
|
|
|
|
|
};
|
|
|
|
|
|
2017-10-13 17:01:49 +08:00
|
|
|
/* MVEBU UART driver structure */
|
|
|
|
|
struct mvebu_uart {
|
2016-02-17 02:14:53 +08:00
|
|
|
struct uart_port *port;
|
2017-10-13 17:01:49 +08:00
|
|
|
struct clk *clk;
|
2017-10-13 17:01:54 +08:00
|
|
|
int irq[UART_IRQ_COUNT];
|
2017-10-13 17:01:49 +08:00
|
|
|
struct mvebu_uart_driver_data *data;
|
2018-04-21 22:07:33 +08:00
|
|
|
#if defined(CONFIG_PM)
|
|
|
|
|
struct mvebu_uart_pm_regs pm_regs;
|
|
|
|
|
#endif /* CONFIG_PM */
|
2016-02-17 02:14:53 +08:00
|
|
|
};
|
|
|
|
|
|
2017-10-13 17:01:49 +08:00
|
|
|
static struct mvebu_uart *to_mvuart(struct uart_port *port)
|
|
|
|
|
{
|
|
|
|
|
return (struct mvebu_uart *)port->private_data;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#define IS_EXTENDED(port) (to_mvuart(port)->data->is_ext)
|
|
|
|
|
|
|
|
|
|
#define UART_RBR(port) (to_mvuart(port)->data->regs.rbr)
|
|
|
|
|
#define UART_TSH(port) (to_mvuart(port)->data->regs.tsh)
|
|
|
|
|
#define UART_CTRL(port) (to_mvuart(port)->data->regs.ctrl)
|
|
|
|
|
#define UART_INTR(port) (to_mvuart(port)->data->regs.intr)
|
|
|
|
|
|
|
|
|
|
#define CTRL_TX_RDY_INT(port) (to_mvuart(port)->data->flags.ctrl_tx_rdy_int)
|
|
|
|
|
#define CTRL_RX_RDY_INT(port) (to_mvuart(port)->data->flags.ctrl_rx_rdy_int)
|
|
|
|
|
#define STAT_TX_RDY(port) (to_mvuart(port)->data->flags.stat_tx_rdy)
|
|
|
|
|
#define STAT_RX_RDY(port) (to_mvuart(port)->data->flags.stat_rx_rdy)
|
|
|
|
|
|
|
|
|
|
static struct uart_port mvebu_uart_ports[MVEBU_NR_UARTS];
|
|
|
|
|
|
serial: mvebu-uart: implement UART clock driver for configuring UART base clock
Implement a new device driver for controlling UART clocks on Marvell
Armada 3700 SoC. This device driver is loaded for devices which match
the compatible string "marvell,armada-3700-uart-clock".
There are more pitfalls related to UART clocks:
- both UARTs use same parent clock source (which can be xtal or one of
the TBG clocks),
- if a TBG clock is used as the parent clock, there are two additional
divisors that can both be configured to divide the rate by 1, 2, ... 6,
but these divisors are again shared between the two UART controllers
on the SOC,
- the configuration of the parent clock source and divisors is done in
the address space of the first UART controller, UART1. Clocks can be
gated separately for UART1 and UART2, but this setting also lives in
the address space of UART1,
- Marvell's Functional Specification for Armada 3720 document has the
clock gating bits swapped, so the one described to gate UART1 clock
actually gates UART2 and vice versa,
- each UART has it's own "special divisor", and this uses the parent
clock described above. These divisors are configure in each UART's
address space separately.
Thus the driver for UART2 controller needs to have access to UART1
address space, since UART1 address space contains some bits exclusive
for UART2 and also some bits which are shared between UART1 and UART2.
Also, during boot, when early console is active on one of the UARTs,
and we want to switch parent clock from xtal (default) to TBG (to be
more flexible with baudrates), the driver changing UART clocks also
needs to be able to change the "special divisor", so that the baudrate
of earlycon is not changed when swtiching to normal console. Thus the
clock driver also needs to be able to access UART2 register space,
for UART2's "special divisor".
For these reasons, this new UART clock driver does not use
ioremap_resource(), but only ioremap() to prevent resource conflicts
between UART clock driver and UART driver.
We need to share only two 32-bit registers between the UART driver and
the UART clock driver:
- UART Clock Control
- UART 2 Baud Rate Divisor
Access to these two registers are protected by one spinlock to prevent
any conflicts. Access is required only during probing, when changing
baudrate or during suspend/resume.
Hardware can be configured to use one of following clocks as UART parent
clock: TBG-A-P, TBG-B-P, TBG-A-S, TBG-B-S, xtal. Not every clock is
usable for higher buadrates. Any subset can be specified in the
device-tree and the driver will choose the best one which also still
supports the mandatory baudrate of 9600 Bd. For smooth boot log output
it is needed to specify clock used by early console, otherwise garbage
would be printed on UART during probe of UART clock driver and
transitioning from early console to normal console.
We are implementing this to be able to configure TBG clock as UART
parent clock, which is required to be able to achieve higher baudrates
than 230400 Bd. We achieve this by referencing this new UART clock
device node in UART's device node. UART clock device driver
automatically chooses the best clock source for UART driver.
Until now, UART's device-tree node needed to reference one of the static
clocks (xtal or one of the TBGs) as parent clock in the `clocks`
phandle - the parent clock which was configured before booting the
kernel. If bootloader changed UART's parent clock, it needed to change
the `clocks` phandle in DTB correspondingly before booting.
From now on both the old mechanism (xtal or TBG referenced as parent
clock in `clocks` phandle) and the new one (UART clock referenced in the
`clocks` phandle) are supported, to provide full backward compatibility
with existing DTS files, full backward compatibility with existing boot
loaders, and to provide new features (runtime clock configuration to
allow higher baudrates than 230400 Bd). New features are available only
with new DTS files.
There was also a discussion about how the UART node and the
clock-controller node could be wrapped together in a new binding [1, 2].
As explained there, this is not possible if we want to keep backwards
compatibility with existing bootloaders, and thus we are doing this by
putting the UART clock-controller node inside the UART1 node.
[1] https://lore.kernel.org/linux-serial/20220120000651.in7s6nazif5qjkme@pali/
[2] https://lore.kernel.org/linux-serial/20220125204006.A6D09C340E0@smtp.kernel.org/
Reviewed-by: Marek Behún <kabel@kernel.org>
Reviewed-by: Stephen Boyd <sboyd@kernel.org>
Signed-off-by: Pali Rohár <pali@kernel.org>
Signed-off-by: Marek Behún <kabel@kernel.org>
Link: https://lore.kernel.org/r/20220219152818.4319-4-kabel@kernel.org
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2022-02-19 23:28:15 +08:00
|
|
|
static DEFINE_SPINLOCK(mvebu_uart_lock);
|
|
|
|
|
|
2016-02-17 02:14:53 +08:00
|
|
|
/* Core UART Driver Operations */
|
|
|
|
|
static unsigned int mvebu_uart_tx_empty(struct uart_port *port)
|
|
|
|
|
{
|
|
|
|
|
unsigned long flags;
|
|
|
|
|
unsigned int st;
|
|
|
|
|
|
|
|
|
|
spin_lock_irqsave(&port->lock, flags);
|
|
|
|
|
st = readl(port->membase + UART_STAT);
|
|
|
|
|
spin_unlock_irqrestore(&port->lock, flags);
|
|
|
|
|
|
2021-09-11 21:20:17 +08:00
|
|
|
return (st & STAT_TX_EMP) ? TIOCSER_TEMT : 0;
|
2016-02-17 02:14:53 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static unsigned int mvebu_uart_get_mctrl(struct uart_port *port)
|
|
|
|
|
{
|
|
|
|
|
return TIOCM_CTS | TIOCM_DSR | TIOCM_CAR;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void mvebu_uart_set_mctrl(struct uart_port *port,
|
|
|
|
|
unsigned int mctrl)
|
|
|
|
|
{
|
|
|
|
|
/*
|
|
|
|
|
* Even if we do not support configuring the modem control lines, this
|
|
|
|
|
* function must be proided to the serial core
|
|
|
|
|
*/
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void mvebu_uart_stop_tx(struct uart_port *port)
|
|
|
|
|
{
|
2017-10-13 17:01:49 +08:00
|
|
|
unsigned int ctl = readl(port->membase + UART_INTR(port));
|
2016-02-17 02:14:53 +08:00
|
|
|
|
2017-10-13 17:01:49 +08:00
|
|
|
ctl &= ~CTRL_TX_RDY_INT(port);
|
|
|
|
|
writel(ctl, port->membase + UART_INTR(port));
|
2016-02-17 02:14:53 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void mvebu_uart_start_tx(struct uart_port *port)
|
|
|
|
|
{
|
2017-10-13 17:01:53 +08:00
|
|
|
unsigned int ctl;
|
|
|
|
|
struct circ_buf *xmit = &port->state->xmit;
|
2016-02-17 02:14:53 +08:00
|
|
|
|
2017-10-13 17:01:53 +08:00
|
|
|
if (IS_EXTENDED(port) && !uart_circ_empty(xmit)) {
|
|
|
|
|
writel(xmit->buf[xmit->tail], port->membase + UART_TSH(port));
|
|
|
|
|
xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
|
|
|
|
|
port->icount.tx++;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ctl = readl(port->membase + UART_INTR(port));
|
2017-10-13 17:01:49 +08:00
|
|
|
ctl |= CTRL_TX_RDY_INT(port);
|
|
|
|
|
writel(ctl, port->membase + UART_INTR(port));
|
2016-02-17 02:14:53 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void mvebu_uart_stop_rx(struct uart_port *port)
|
|
|
|
|
{
|
2017-10-13 17:01:49 +08:00
|
|
|
unsigned int ctl;
|
2016-02-17 02:14:53 +08:00
|
|
|
|
2017-10-13 17:01:49 +08:00
|
|
|
ctl = readl(port->membase + UART_CTRL(port));
|
|
|
|
|
ctl &= ~CTRL_BRK_INT;
|
|
|
|
|
writel(ctl, port->membase + UART_CTRL(port));
|
|
|
|
|
|
|
|
|
|
ctl = readl(port->membase + UART_INTR(port));
|
|
|
|
|
ctl &= ~CTRL_RX_RDY_INT(port);
|
|
|
|
|
writel(ctl, port->membase + UART_INTR(port));
|
2016-02-17 02:14:53 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void mvebu_uart_break_ctl(struct uart_port *port, int brk)
|
|
|
|
|
{
|
|
|
|
|
unsigned int ctl;
|
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
|
|
spin_lock_irqsave(&port->lock, flags);
|
2017-10-13 17:01:49 +08:00
|
|
|
ctl = readl(port->membase + UART_CTRL(port));
|
2016-02-17 02:14:53 +08:00
|
|
|
if (brk == -1)
|
|
|
|
|
ctl |= CTRL_SND_BRK_SEQ;
|
|
|
|
|
else
|
|
|
|
|
ctl &= ~CTRL_SND_BRK_SEQ;
|
2017-10-13 17:01:49 +08:00
|
|
|
writel(ctl, port->membase + UART_CTRL(port));
|
2016-02-17 02:14:53 +08:00
|
|
|
spin_unlock_irqrestore(&port->lock, flags);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void mvebu_uart_rx_chars(struct uart_port *port, unsigned int status)
|
|
|
|
|
{
|
|
|
|
|
struct tty_port *tport = &port->state->port;
|
|
|
|
|
unsigned char ch = 0;
|
|
|
|
|
char flag = 0;
|
2022-07-26 17:12:21 +08:00
|
|
|
int ret;
|
2016-02-17 02:14:53 +08:00
|
|
|
|
|
|
|
|
do {
|
2017-10-13 17:01:49 +08:00
|
|
|
if (status & STAT_RX_RDY(port)) {
|
|
|
|
|
ch = readl(port->membase + UART_RBR(port));
|
2016-02-17 02:14:53 +08:00
|
|
|
ch &= 0xff;
|
|
|
|
|
flag = TTY_NORMAL;
|
|
|
|
|
port->icount.rx++;
|
|
|
|
|
|
|
|
|
|
if (status & STAT_PAR_ERR)
|
|
|
|
|
port->icount.parity++;
|
|
|
|
|
}
|
|
|
|
|
|
2022-07-26 17:12:21 +08:00
|
|
|
/*
|
|
|
|
|
* For UART2, error bits are not cleared on buffer read.
|
|
|
|
|
* This causes interrupt loop and system hang.
|
|
|
|
|
*/
|
|
|
|
|
if (IS_EXTENDED(port) && (status & STAT_BRK_ERR)) {
|
|
|
|
|
ret = readl(port->membase + UART_STAT);
|
|
|
|
|
ret |= STAT_BRK_ERR;
|
|
|
|
|
writel(ret, port->membase + UART_STAT);
|
|
|
|
|
}
|
|
|
|
|
|
2016-02-17 02:14:53 +08:00
|
|
|
if (status & STAT_BRK_DET) {
|
|
|
|
|
port->icount.brk++;
|
|
|
|
|
status &= ~(STAT_FRM_ERR | STAT_PAR_ERR);
|
|
|
|
|
if (uart_handle_break(port))
|
|
|
|
|
goto ignore_char;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (status & STAT_OVR_ERR)
|
|
|
|
|
port->icount.overrun++;
|
|
|
|
|
|
|
|
|
|
if (status & STAT_FRM_ERR)
|
|
|
|
|
port->icount.frame++;
|
|
|
|
|
|
|
|
|
|
if (uart_handle_sysrq_char(port, ch))
|
|
|
|
|
goto ignore_char;
|
|
|
|
|
|
|
|
|
|
if (status & port->ignore_status_mask & STAT_PAR_ERR)
|
2017-10-13 17:01:49 +08:00
|
|
|
status &= ~STAT_RX_RDY(port);
|
2016-02-17 02:14:53 +08:00
|
|
|
|
|
|
|
|
status &= port->read_status_mask;
|
|
|
|
|
|
|
|
|
|
if (status & STAT_PAR_ERR)
|
|
|
|
|
flag = TTY_PARITY;
|
|
|
|
|
|
|
|
|
|
status &= ~port->ignore_status_mask;
|
|
|
|
|
|
2017-10-13 17:01:49 +08:00
|
|
|
if (status & STAT_RX_RDY(port))
|
2016-02-17 02:14:53 +08:00
|
|
|
tty_insert_flip_char(tport, ch, flag);
|
|
|
|
|
|
|
|
|
|
if (status & STAT_BRK_DET)
|
|
|
|
|
tty_insert_flip_char(tport, 0, TTY_BREAK);
|
|
|
|
|
|
|
|
|
|
if (status & STAT_FRM_ERR)
|
|
|
|
|
tty_insert_flip_char(tport, 0, TTY_FRAME);
|
|
|
|
|
|
|
|
|
|
if (status & STAT_OVR_ERR)
|
|
|
|
|
tty_insert_flip_char(tport, 0, TTY_OVERRUN);
|
|
|
|
|
|
|
|
|
|
ignore_char:
|
|
|
|
|
status = readl(port->membase + UART_STAT);
|
2017-10-13 17:01:49 +08:00
|
|
|
} while (status & (STAT_RX_RDY(port) | STAT_BRK_DET));
|
2016-02-17 02:14:53 +08:00
|
|
|
|
|
|
|
|
tty_flip_buffer_push(tport);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void mvebu_uart_tx_chars(struct uart_port *port, unsigned int status)
|
|
|
|
|
{
|
|
|
|
|
struct circ_buf *xmit = &port->state->xmit;
|
|
|
|
|
unsigned int count;
|
|
|
|
|
unsigned int st;
|
|
|
|
|
|
|
|
|
|
if (port->x_char) {
|
2017-10-13 17:01:49 +08:00
|
|
|
writel(port->x_char, port->membase + UART_TSH(port));
|
2016-02-17 02:14:53 +08:00
|
|
|
port->icount.tx++;
|
|
|
|
|
port->x_char = 0;
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (uart_circ_empty(xmit) || uart_tx_stopped(port)) {
|
|
|
|
|
mvebu_uart_stop_tx(port);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (count = 0; count < port->fifosize; count++) {
|
2017-10-13 17:01:49 +08:00
|
|
|
writel(xmit->buf[xmit->tail], port->membase + UART_TSH(port));
|
2016-02-17 02:14:53 +08:00
|
|
|
xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
|
|
|
|
|
port->icount.tx++;
|
|
|
|
|
|
|
|
|
|
if (uart_circ_empty(xmit))
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
st = readl(port->membase + UART_STAT);
|
|
|
|
|
if (st & STAT_TX_FIFO_FUL)
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
|
|
|
|
|
uart_write_wakeup(port);
|
|
|
|
|
|
|
|
|
|
if (uart_circ_empty(xmit))
|
|
|
|
|
mvebu_uart_stop_tx(port);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static irqreturn_t mvebu_uart_isr(int irq, void *dev_id)
|
|
|
|
|
{
|
|
|
|
|
struct uart_port *port = (struct uart_port *)dev_id;
|
|
|
|
|
unsigned int st = readl(port->membase + UART_STAT);
|
|
|
|
|
|
2017-10-13 17:01:54 +08:00
|
|
|
if (st & (STAT_RX_RDY(port) | STAT_OVR_ERR | STAT_FRM_ERR |
|
|
|
|
|
STAT_BRK_DET))
|
|
|
|
|
mvebu_uart_rx_chars(port, st);
|
|
|
|
|
|
|
|
|
|
if (st & STAT_TX_RDY(port))
|
|
|
|
|
mvebu_uart_tx_chars(port, st);
|
|
|
|
|
|
|
|
|
|
return IRQ_HANDLED;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static irqreturn_t mvebu_uart_rx_isr(int irq, void *dev_id)
|
|
|
|
|
{
|
|
|
|
|
struct uart_port *port = (struct uart_port *)dev_id;
|
|
|
|
|
unsigned int st = readl(port->membase + UART_STAT);
|
|
|
|
|
|
2017-10-13 17:01:49 +08:00
|
|
|
if (st & (STAT_RX_RDY(port) | STAT_OVR_ERR | STAT_FRM_ERR |
|
|
|
|
|
STAT_BRK_DET))
|
2016-02-17 02:14:53 +08:00
|
|
|
mvebu_uart_rx_chars(port, st);
|
|
|
|
|
|
2017-10-13 17:01:54 +08:00
|
|
|
return IRQ_HANDLED;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static irqreturn_t mvebu_uart_tx_isr(int irq, void *dev_id)
|
|
|
|
|
{
|
|
|
|
|
struct uart_port *port = (struct uart_port *)dev_id;
|
|
|
|
|
unsigned int st = readl(port->membase + UART_STAT);
|
|
|
|
|
|
2017-10-13 17:01:49 +08:00
|
|
|
if (st & STAT_TX_RDY(port))
|
2016-02-17 02:14:53 +08:00
|
|
|
mvebu_uart_tx_chars(port, st);
|
|
|
|
|
|
|
|
|
|
return IRQ_HANDLED;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int mvebu_uart_startup(struct uart_port *port)
|
|
|
|
|
{
|
2017-10-13 17:01:54 +08:00
|
|
|
struct mvebu_uart *mvuart = to_mvuart(port);
|
2017-10-13 17:01:49 +08:00
|
|
|
unsigned int ctl;
|
2016-02-17 02:14:53 +08:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
|
|
writel(CTRL_TXFIFO_RST | CTRL_RXFIFO_RST,
|
2017-10-13 17:01:49 +08:00
|
|
|
port->membase + UART_CTRL(port));
|
2016-02-17 02:14:53 +08:00
|
|
|
udelay(1);
|
2017-10-13 17:01:52 +08:00
|
|
|
|
|
|
|
|
/* Clear the error bits of state register before IRQ request */
|
|
|
|
|
ret = readl(port->membase + UART_STAT);
|
|
|
|
|
ret |= STAT_BRK_ERR;
|
|
|
|
|
writel(ret, port->membase + UART_STAT);
|
|
|
|
|
|
2017-10-13 17:01:49 +08:00
|
|
|
writel(CTRL_BRK_INT, port->membase + UART_CTRL(port));
|
|
|
|
|
|
|
|
|
|
ctl = readl(port->membase + UART_INTR(port));
|
|
|
|
|
ctl |= CTRL_RX_RDY_INT(port);
|
|
|
|
|
writel(ctl, port->membase + UART_INTR(port));
|
2016-02-17 02:14:53 +08:00
|
|
|
|
2017-10-13 17:01:54 +08:00
|
|
|
if (!mvuart->irq[UART_TX_IRQ]) {
|
|
|
|
|
/* Old bindings with just one interrupt (UART0 only) */
|
|
|
|
|
ret = devm_request_irq(port->dev, mvuart->irq[UART_IRQ_SUM],
|
|
|
|
|
mvebu_uart_isr, port->irqflags,
|
|
|
|
|
dev_name(port->dev), port);
|
|
|
|
|
if (ret) {
|
|
|
|
|
dev_err(port->dev, "unable to request IRQ %d\n",
|
|
|
|
|
mvuart->irq[UART_IRQ_SUM]);
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
/* New bindings with an IRQ for RX and TX (both UART) */
|
|
|
|
|
ret = devm_request_irq(port->dev, mvuart->irq[UART_RX_IRQ],
|
|
|
|
|
mvebu_uart_rx_isr, port->irqflags,
|
|
|
|
|
dev_name(port->dev), port);
|
|
|
|
|
if (ret) {
|
|
|
|
|
dev_err(port->dev, "unable to request IRQ %d\n",
|
|
|
|
|
mvuart->irq[UART_RX_IRQ]);
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ret = devm_request_irq(port->dev, mvuart->irq[UART_TX_IRQ],
|
|
|
|
|
mvebu_uart_tx_isr, port->irqflags,
|
|
|
|
|
dev_name(port->dev),
|
|
|
|
|
port);
|
|
|
|
|
if (ret) {
|
|
|
|
|
dev_err(port->dev, "unable to request IRQ %d\n",
|
|
|
|
|
mvuart->irq[UART_TX_IRQ]);
|
|
|
|
|
devm_free_irq(port->dev, mvuart->irq[UART_RX_IRQ],
|
|
|
|
|
port);
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
2016-02-17 02:14:53 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void mvebu_uart_shutdown(struct uart_port *port)
|
|
|
|
|
{
|
2017-10-13 17:01:54 +08:00
|
|
|
struct mvebu_uart *mvuart = to_mvuart(port);
|
|
|
|
|
|
2017-10-13 17:01:49 +08:00
|
|
|
writel(0, port->membase + UART_INTR(port));
|
2016-06-16 22:48:52 +08:00
|
|
|
|
2017-10-13 17:01:54 +08:00
|
|
|
if (!mvuart->irq[UART_TX_IRQ]) {
|
|
|
|
|
devm_free_irq(port->dev, mvuart->irq[UART_IRQ_SUM], port);
|
|
|
|
|
} else {
|
|
|
|
|
devm_free_irq(port->dev, mvuart->irq[UART_RX_IRQ], port);
|
|
|
|
|
devm_free_irq(port->dev, mvuart->irq[UART_TX_IRQ], port);
|
|
|
|
|
}
|
2016-02-17 02:14:53 +08:00
|
|
|
}
|
|
|
|
|
|
2022-06-28 18:09:22 +08:00
|
|
|
static unsigned int mvebu_uart_baud_rate_set(struct uart_port *port, unsigned int baud)
|
2017-10-13 17:01:51 +08:00
|
|
|
{
|
2018-11-23 23:45:29 +08:00
|
|
|
unsigned int d_divisor, m_divisor;
|
serial: mvebu-uart: implement UART clock driver for configuring UART base clock
Implement a new device driver for controlling UART clocks on Marvell
Armada 3700 SoC. This device driver is loaded for devices which match
the compatible string "marvell,armada-3700-uart-clock".
There are more pitfalls related to UART clocks:
- both UARTs use same parent clock source (which can be xtal or one of
the TBG clocks),
- if a TBG clock is used as the parent clock, there are two additional
divisors that can both be configured to divide the rate by 1, 2, ... 6,
but these divisors are again shared between the two UART controllers
on the SOC,
- the configuration of the parent clock source and divisors is done in
the address space of the first UART controller, UART1. Clocks can be
gated separately for UART1 and UART2, but this setting also lives in
the address space of UART1,
- Marvell's Functional Specification for Armada 3720 document has the
clock gating bits swapped, so the one described to gate UART1 clock
actually gates UART2 and vice versa,
- each UART has it's own "special divisor", and this uses the parent
clock described above. These divisors are configure in each UART's
address space separately.
Thus the driver for UART2 controller needs to have access to UART1
address space, since UART1 address space contains some bits exclusive
for UART2 and also some bits which are shared between UART1 and UART2.
Also, during boot, when early console is active on one of the UARTs,
and we want to switch parent clock from xtal (default) to TBG (to be
more flexible with baudrates), the driver changing UART clocks also
needs to be able to change the "special divisor", so that the baudrate
of earlycon is not changed when swtiching to normal console. Thus the
clock driver also needs to be able to access UART2 register space,
for UART2's "special divisor".
For these reasons, this new UART clock driver does not use
ioremap_resource(), but only ioremap() to prevent resource conflicts
between UART clock driver and UART driver.
We need to share only two 32-bit registers between the UART driver and
the UART clock driver:
- UART Clock Control
- UART 2 Baud Rate Divisor
Access to these two registers are protected by one spinlock to prevent
any conflicts. Access is required only during probing, when changing
baudrate or during suspend/resume.
Hardware can be configured to use one of following clocks as UART parent
clock: TBG-A-P, TBG-B-P, TBG-A-S, TBG-B-S, xtal. Not every clock is
usable for higher buadrates. Any subset can be specified in the
device-tree and the driver will choose the best one which also still
supports the mandatory baudrate of 9600 Bd. For smooth boot log output
it is needed to specify clock used by early console, otherwise garbage
would be printed on UART during probe of UART clock driver and
transitioning from early console to normal console.
We are implementing this to be able to configure TBG clock as UART
parent clock, which is required to be able to achieve higher baudrates
than 230400 Bd. We achieve this by referencing this new UART clock
device node in UART's device node. UART clock device driver
automatically chooses the best clock source for UART driver.
Until now, UART's device-tree node needed to reference one of the static
clocks (xtal or one of the TBGs) as parent clock in the `clocks`
phandle - the parent clock which was configured before booting the
kernel. If bootloader changed UART's parent clock, it needed to change
the `clocks` phandle in DTB correspondingly before booting.
From now on both the old mechanism (xtal or TBG referenced as parent
clock in `clocks` phandle) and the new one (UART clock referenced in the
`clocks` phandle) are supported, to provide full backward compatibility
with existing DTS files, full backward compatibility with existing boot
loaders, and to provide new features (runtime clock configuration to
allow higher baudrates than 230400 Bd). New features are available only
with new DTS files.
There was also a discussion about how the UART node and the
clock-controller node could be wrapped together in a new binding [1, 2].
As explained there, this is not possible if we want to keep backwards
compatibility with existing bootloaders, and thus we are doing this by
putting the UART clock-controller node inside the UART1 node.
[1] https://lore.kernel.org/linux-serial/20220120000651.in7s6nazif5qjkme@pali/
[2] https://lore.kernel.org/linux-serial/20220125204006.A6D09C340E0@smtp.kernel.org/
Reviewed-by: Marek Behún <kabel@kernel.org>
Reviewed-by: Stephen Boyd <sboyd@kernel.org>
Signed-off-by: Pali Rohár <pali@kernel.org>
Signed-off-by: Marek Behún <kabel@kernel.org>
Link: https://lore.kernel.org/r/20220219152818.4319-4-kabel@kernel.org
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2022-02-19 23:28:15 +08:00
|
|
|
unsigned long flags;
|
2018-11-23 23:45:30 +08:00
|
|
|
u32 brdv, osamp;
|
2017-10-13 17:01:51 +08:00
|
|
|
|
2021-06-25 06:49:01 +08:00
|
|
|
if (!port->uartclk)
|
2022-06-28 18:09:22 +08:00
|
|
|
return 0;
|
2017-10-13 17:01:51 +08:00
|
|
|
|
|
|
|
|
/*
|
2022-02-19 23:28:17 +08:00
|
|
|
* The baudrate is derived from the UART clock thanks to divisors:
|
|
|
|
|
* > d1 * d2 ("TBG divisors"): can divide only TBG clock from 1 to 6
|
|
|
|
|
* > D ("baud generator"): can divide the clock from 1 to 1023
|
|
|
|
|
* > M ("fractional divisor"): allows a better accuracy (from 1 to 63)
|
2018-11-23 23:45:29 +08:00
|
|
|
*
|
2022-02-19 23:28:17 +08:00
|
|
|
* Exact formulas for calculating baudrate:
|
|
|
|
|
*
|
|
|
|
|
* with default x16 scheme:
|
|
|
|
|
* baudrate = xtal / (d * 16)
|
|
|
|
|
* baudrate = tbg / (d1 * d2 * d * 16)
|
|
|
|
|
*
|
|
|
|
|
* with fractional divisor:
|
|
|
|
|
* baudrate = 10 * xtal / (d * (3 * (m1 + m2) + 2 * (m3 + m4)))
|
|
|
|
|
* baudrate = 10 * tbg / (d1*d2 * d * (3 * (m1 + m2) + 2 * (m3 + m4)))
|
|
|
|
|
*
|
|
|
|
|
* Oversampling value:
|
|
|
|
|
* osamp = (m1 << 0) | (m2 << 8) | (m3 << 16) | (m4 << 24);
|
|
|
|
|
*
|
|
|
|
|
* Where m1 controls number of clock cycles per bit for bits 1,2,3;
|
|
|
|
|
* m2 for bits 4,5,6; m3 for bits 7,8 and m4 for bits 9,10.
|
|
|
|
|
*
|
|
|
|
|
* To simplify baudrate setup set all the M prescalers to the same
|
|
|
|
|
* value. For baudrates 9600 Bd and higher, it is enough to use the
|
|
|
|
|
* default (x16) divisor or fractional divisor with M = 63, so there
|
|
|
|
|
* is no need to use real fractional support (where the M prescalers
|
|
|
|
|
* are not equal).
|
|
|
|
|
*
|
|
|
|
|
* When all the M prescalers are zeroed then default (x16) divisor is
|
|
|
|
|
* used. Default x16 scheme is more stable than M (fractional divisor),
|
|
|
|
|
* so use M only when D divisor is not enough to derive baudrate.
|
|
|
|
|
*
|
|
|
|
|
* Member port->uartclk is either xtal clock rate or TBG clock rate
|
|
|
|
|
* divided by (d1 * d2). So d1 and d2 are already set by the UART clock
|
|
|
|
|
* driver (and UART driver itself cannot change them). Moreover they are
|
|
|
|
|
* shared between both UARTs.
|
2017-10-13 17:01:51 +08:00
|
|
|
*/
|
2022-02-19 23:28:17 +08:00
|
|
|
|
2018-11-23 23:45:29 +08:00
|
|
|
m_divisor = OSAMP_DEFAULT_DIVISOR;
|
2021-06-25 06:49:00 +08:00
|
|
|
d_divisor = DIV_ROUND_CLOSEST(port->uartclk, baud * m_divisor);
|
2018-11-23 23:45:29 +08:00
|
|
|
|
2022-02-19 23:28:17 +08:00
|
|
|
if (d_divisor > BRDV_BAUD_MAX) {
|
|
|
|
|
/*
|
|
|
|
|
* Experiments show that small M divisors are unstable.
|
|
|
|
|
* Use maximal possible M = 63 and calculate D divisor.
|
|
|
|
|
*/
|
|
|
|
|
m_divisor = OSAMP_MAX_DIVISOR;
|
|
|
|
|
d_divisor = DIV_ROUND_CLOSEST(port->uartclk, baud * m_divisor);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (d_divisor < 1)
|
|
|
|
|
d_divisor = 1;
|
|
|
|
|
else if (d_divisor > BRDV_BAUD_MAX)
|
|
|
|
|
d_divisor = BRDV_BAUD_MAX;
|
|
|
|
|
|
serial: mvebu-uart: implement UART clock driver for configuring UART base clock
Implement a new device driver for controlling UART clocks on Marvell
Armada 3700 SoC. This device driver is loaded for devices which match
the compatible string "marvell,armada-3700-uart-clock".
There are more pitfalls related to UART clocks:
- both UARTs use same parent clock source (which can be xtal or one of
the TBG clocks),
- if a TBG clock is used as the parent clock, there are two additional
divisors that can both be configured to divide the rate by 1, 2, ... 6,
but these divisors are again shared between the two UART controllers
on the SOC,
- the configuration of the parent clock source and divisors is done in
the address space of the first UART controller, UART1. Clocks can be
gated separately for UART1 and UART2, but this setting also lives in
the address space of UART1,
- Marvell's Functional Specification for Armada 3720 document has the
clock gating bits swapped, so the one described to gate UART1 clock
actually gates UART2 and vice versa,
- each UART has it's own "special divisor", and this uses the parent
clock described above. These divisors are configure in each UART's
address space separately.
Thus the driver for UART2 controller needs to have access to UART1
address space, since UART1 address space contains some bits exclusive
for UART2 and also some bits which are shared between UART1 and UART2.
Also, during boot, when early console is active on one of the UARTs,
and we want to switch parent clock from xtal (default) to TBG (to be
more flexible with baudrates), the driver changing UART clocks also
needs to be able to change the "special divisor", so that the baudrate
of earlycon is not changed when swtiching to normal console. Thus the
clock driver also needs to be able to access UART2 register space,
for UART2's "special divisor".
For these reasons, this new UART clock driver does not use
ioremap_resource(), but only ioremap() to prevent resource conflicts
between UART clock driver and UART driver.
We need to share only two 32-bit registers between the UART driver and
the UART clock driver:
- UART Clock Control
- UART 2 Baud Rate Divisor
Access to these two registers are protected by one spinlock to prevent
any conflicts. Access is required only during probing, when changing
baudrate or during suspend/resume.
Hardware can be configured to use one of following clocks as UART parent
clock: TBG-A-P, TBG-B-P, TBG-A-S, TBG-B-S, xtal. Not every clock is
usable for higher buadrates. Any subset can be specified in the
device-tree and the driver will choose the best one which also still
supports the mandatory baudrate of 9600 Bd. For smooth boot log output
it is needed to specify clock used by early console, otherwise garbage
would be printed on UART during probe of UART clock driver and
transitioning from early console to normal console.
We are implementing this to be able to configure TBG clock as UART
parent clock, which is required to be able to achieve higher baudrates
than 230400 Bd. We achieve this by referencing this new UART clock
device node in UART's device node. UART clock device driver
automatically chooses the best clock source for UART driver.
Until now, UART's device-tree node needed to reference one of the static
clocks (xtal or one of the TBGs) as parent clock in the `clocks`
phandle - the parent clock which was configured before booting the
kernel. If bootloader changed UART's parent clock, it needed to change
the `clocks` phandle in DTB correspondingly before booting.
From now on both the old mechanism (xtal or TBG referenced as parent
clock in `clocks` phandle) and the new one (UART clock referenced in the
`clocks` phandle) are supported, to provide full backward compatibility
with existing DTS files, full backward compatibility with existing boot
loaders, and to provide new features (runtime clock configuration to
allow higher baudrates than 230400 Bd). New features are available only
with new DTS files.
There was also a discussion about how the UART node and the
clock-controller node could be wrapped together in a new binding [1, 2].
As explained there, this is not possible if we want to keep backwards
compatibility with existing bootloaders, and thus we are doing this by
putting the UART clock-controller node inside the UART1 node.
[1] https://lore.kernel.org/linux-serial/20220120000651.in7s6nazif5qjkme@pali/
[2] https://lore.kernel.org/linux-serial/20220125204006.A6D09C340E0@smtp.kernel.org/
Reviewed-by: Marek Behún <kabel@kernel.org>
Reviewed-by: Stephen Boyd <sboyd@kernel.org>
Signed-off-by: Pali Rohár <pali@kernel.org>
Signed-off-by: Marek Behún <kabel@kernel.org>
Link: https://lore.kernel.org/r/20220219152818.4319-4-kabel@kernel.org
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2022-02-19 23:28:15 +08:00
|
|
|
spin_lock_irqsave(&mvebu_uart_lock, flags);
|
2017-10-13 17:01:51 +08:00
|
|
|
brdv = readl(port->membase + UART_BRDV);
|
|
|
|
|
brdv &= ~BRDV_BAUD_MASK;
|
2018-11-23 23:45:29 +08:00
|
|
|
brdv |= d_divisor;
|
2017-10-13 17:01:51 +08:00
|
|
|
writel(brdv, port->membase + UART_BRDV);
|
serial: mvebu-uart: implement UART clock driver for configuring UART base clock
Implement a new device driver for controlling UART clocks on Marvell
Armada 3700 SoC. This device driver is loaded for devices which match
the compatible string "marvell,armada-3700-uart-clock".
There are more pitfalls related to UART clocks:
- both UARTs use same parent clock source (which can be xtal or one of
the TBG clocks),
- if a TBG clock is used as the parent clock, there are two additional
divisors that can both be configured to divide the rate by 1, 2, ... 6,
but these divisors are again shared between the two UART controllers
on the SOC,
- the configuration of the parent clock source and divisors is done in
the address space of the first UART controller, UART1. Clocks can be
gated separately for UART1 and UART2, but this setting also lives in
the address space of UART1,
- Marvell's Functional Specification for Armada 3720 document has the
clock gating bits swapped, so the one described to gate UART1 clock
actually gates UART2 and vice versa,
- each UART has it's own "special divisor", and this uses the parent
clock described above. These divisors are configure in each UART's
address space separately.
Thus the driver for UART2 controller needs to have access to UART1
address space, since UART1 address space contains some bits exclusive
for UART2 and also some bits which are shared between UART1 and UART2.
Also, during boot, when early console is active on one of the UARTs,
and we want to switch parent clock from xtal (default) to TBG (to be
more flexible with baudrates), the driver changing UART clocks also
needs to be able to change the "special divisor", so that the baudrate
of earlycon is not changed when swtiching to normal console. Thus the
clock driver also needs to be able to access UART2 register space,
for UART2's "special divisor".
For these reasons, this new UART clock driver does not use
ioremap_resource(), but only ioremap() to prevent resource conflicts
between UART clock driver and UART driver.
We need to share only two 32-bit registers between the UART driver and
the UART clock driver:
- UART Clock Control
- UART 2 Baud Rate Divisor
Access to these two registers are protected by one spinlock to prevent
any conflicts. Access is required only during probing, when changing
baudrate or during suspend/resume.
Hardware can be configured to use one of following clocks as UART parent
clock: TBG-A-P, TBG-B-P, TBG-A-S, TBG-B-S, xtal. Not every clock is
usable for higher buadrates. Any subset can be specified in the
device-tree and the driver will choose the best one which also still
supports the mandatory baudrate of 9600 Bd. For smooth boot log output
it is needed to specify clock used by early console, otherwise garbage
would be printed on UART during probe of UART clock driver and
transitioning from early console to normal console.
We are implementing this to be able to configure TBG clock as UART
parent clock, which is required to be able to achieve higher baudrates
than 230400 Bd. We achieve this by referencing this new UART clock
device node in UART's device node. UART clock device driver
automatically chooses the best clock source for UART driver.
Until now, UART's device-tree node needed to reference one of the static
clocks (xtal or one of the TBGs) as parent clock in the `clocks`
phandle - the parent clock which was configured before booting the
kernel. If bootloader changed UART's parent clock, it needed to change
the `clocks` phandle in DTB correspondingly before booting.
From now on both the old mechanism (xtal or TBG referenced as parent
clock in `clocks` phandle) and the new one (UART clock referenced in the
`clocks` phandle) are supported, to provide full backward compatibility
with existing DTS files, full backward compatibility with existing boot
loaders, and to provide new features (runtime clock configuration to
allow higher baudrates than 230400 Bd). New features are available only
with new DTS files.
There was also a discussion about how the UART node and the
clock-controller node could be wrapped together in a new binding [1, 2].
As explained there, this is not possible if we want to keep backwards
compatibility with existing bootloaders, and thus we are doing this by
putting the UART clock-controller node inside the UART1 node.
[1] https://lore.kernel.org/linux-serial/20220120000651.in7s6nazif5qjkme@pali/
[2] https://lore.kernel.org/linux-serial/20220125204006.A6D09C340E0@smtp.kernel.org/
Reviewed-by: Marek Behún <kabel@kernel.org>
Reviewed-by: Stephen Boyd <sboyd@kernel.org>
Signed-off-by: Pali Rohár <pali@kernel.org>
Signed-off-by: Marek Behún <kabel@kernel.org>
Link: https://lore.kernel.org/r/20220219152818.4319-4-kabel@kernel.org
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2022-02-19 23:28:15 +08:00
|
|
|
spin_unlock_irqrestore(&mvebu_uart_lock, flags);
|
2017-10-13 17:01:51 +08:00
|
|
|
|
2018-11-23 23:45:30 +08:00
|
|
|
osamp = readl(port->membase + UART_OSAMP);
|
|
|
|
|
osamp &= ~OSAMP_DIVISORS_MASK;
|
2022-02-19 23:28:17 +08:00
|
|
|
if (m_divisor != OSAMP_DEFAULT_DIVISOR)
|
|
|
|
|
osamp |= (m_divisor << 0) | (m_divisor << 8) |
|
|
|
|
|
(m_divisor << 16) | (m_divisor << 24);
|
2018-11-23 23:45:30 +08:00
|
|
|
writel(osamp, port->membase + UART_OSAMP);
|
|
|
|
|
|
2022-06-28 18:09:22 +08:00
|
|
|
return DIV_ROUND_CLOSEST(port->uartclk, d_divisor * m_divisor);
|
2017-10-13 17:01:51 +08:00
|
|
|
}
|
|
|
|
|
|
2016-02-17 02:14:53 +08:00
|
|
|
static void mvebu_uart_set_termios(struct uart_port *port,
|
|
|
|
|
struct ktermios *termios,
|
|
|
|
|
struct ktermios *old)
|
|
|
|
|
{
|
|
|
|
|
unsigned long flags;
|
2021-06-25 06:49:02 +08:00
|
|
|
unsigned int baud, min_baud, max_baud;
|
2016-02-17 02:14:53 +08:00
|
|
|
|
|
|
|
|
spin_lock_irqsave(&port->lock, flags);
|
|
|
|
|
|
2017-10-13 17:01:49 +08:00
|
|
|
port->read_status_mask = STAT_RX_RDY(port) | STAT_OVR_ERR |
|
|
|
|
|
STAT_TX_RDY(port) | STAT_TX_FIFO_FUL;
|
2016-02-17 02:14:53 +08:00
|
|
|
|
|
|
|
|
if (termios->c_iflag & INPCK)
|
|
|
|
|
port->read_status_mask |= STAT_FRM_ERR | STAT_PAR_ERR;
|
|
|
|
|
|
|
|
|
|
port->ignore_status_mask = 0;
|
|
|
|
|
if (termios->c_iflag & IGNPAR)
|
|
|
|
|
port->ignore_status_mask |=
|
|
|
|
|
STAT_FRM_ERR | STAT_PAR_ERR | STAT_OVR_ERR;
|
|
|
|
|
|
|
|
|
|
if ((termios->c_cflag & CREAD) == 0)
|
2017-10-13 17:01:49 +08:00
|
|
|
port->ignore_status_mask |= STAT_RX_RDY(port) | STAT_BRK_ERR;
|
2016-02-17 02:14:53 +08:00
|
|
|
|
2017-10-13 17:01:51 +08:00
|
|
|
/*
|
2022-02-19 23:28:17 +08:00
|
|
|
* Maximal divisor is 1023 and maximal fractional divisor is 63. And
|
|
|
|
|
* experiments show that baudrates above 1/80 of parent clock rate are
|
|
|
|
|
* not stable. So disallow baudrates above 1/80 of the parent clock
|
|
|
|
|
* rate. If port->uartclk is not available, then
|
|
|
|
|
* mvebu_uart_baud_rate_set() fails, so values min_baud and max_baud
|
|
|
|
|
* in this case do not matter.
|
2017-10-13 17:01:51 +08:00
|
|
|
*/
|
2022-02-19 23:28:17 +08:00
|
|
|
min_baud = DIV_ROUND_UP(port->uartclk, BRDV_BAUD_MAX *
|
|
|
|
|
OSAMP_MAX_DIVISOR);
|
|
|
|
|
max_baud = port->uartclk / 80;
|
2021-06-25 06:49:02 +08:00
|
|
|
|
|
|
|
|
baud = uart_get_baud_rate(port, termios, old, min_baud, max_baud);
|
2022-06-28 18:09:22 +08:00
|
|
|
baud = mvebu_uart_baud_rate_set(port, baud);
|
|
|
|
|
|
|
|
|
|
/* In case baudrate cannot be changed, report previous old value */
|
|
|
|
|
if (baud == 0 && old)
|
|
|
|
|
baud = tty_termios_baud_rate(old);
|
2016-02-17 02:14:53 +08:00
|
|
|
|
2017-10-13 17:01:51 +08:00
|
|
|
/* Only the following flag changes are supported */
|
|
|
|
|
if (old) {
|
|
|
|
|
termios->c_iflag &= INPCK | IGNPAR;
|
|
|
|
|
termios->c_iflag |= old->c_iflag & ~(INPCK | IGNPAR);
|
|
|
|
|
termios->c_cflag &= CREAD | CBAUD;
|
|
|
|
|
termios->c_cflag |= old->c_cflag & ~(CREAD | CBAUD);
|
2018-08-27 01:49:32 +08:00
|
|
|
termios->c_cflag |= CS8;
|
2017-10-13 17:01:51 +08:00
|
|
|
}
|
2016-02-17 02:14:53 +08:00
|
|
|
|
2022-06-28 18:09:22 +08:00
|
|
|
if (baud != 0) {
|
|
|
|
|
tty_termios_encode_baud_rate(termios, baud, baud);
|
|
|
|
|
uart_update_timeout(port, termios->c_cflag, baud);
|
|
|
|
|
}
|
|
|
|
|
|
2016-02-17 02:14:53 +08:00
|
|
|
spin_unlock_irqrestore(&port->lock, flags);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static const char *mvebu_uart_type(struct uart_port *port)
|
|
|
|
|
{
|
|
|
|
|
return MVEBU_UART_TYPE;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void mvebu_uart_release_port(struct uart_port *port)
|
|
|
|
|
{
|
|
|
|
|
/* Nothing to do here */
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int mvebu_uart_request_port(struct uart_port *port)
|
|
|
|
|
{
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#ifdef CONFIG_CONSOLE_POLL
|
|
|
|
|
static int mvebu_uart_get_poll_char(struct uart_port *port)
|
|
|
|
|
{
|
|
|
|
|
unsigned int st = readl(port->membase + UART_STAT);
|
|
|
|
|
|
2017-10-13 17:01:49 +08:00
|
|
|
if (!(st & STAT_RX_RDY(port)))
|
2016-02-17 02:14:53 +08:00
|
|
|
return NO_POLL_CHAR;
|
|
|
|
|
|
2017-10-13 17:01:49 +08:00
|
|
|
return readl(port->membase + UART_RBR(port));
|
2016-02-17 02:14:53 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void mvebu_uart_put_poll_char(struct uart_port *port, unsigned char c)
|
|
|
|
|
{
|
|
|
|
|
unsigned int st;
|
|
|
|
|
|
|
|
|
|
for (;;) {
|
|
|
|
|
st = readl(port->membase + UART_STAT);
|
|
|
|
|
|
|
|
|
|
if (!(st & STAT_TX_FIFO_FUL))
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
udelay(1);
|
|
|
|
|
}
|
|
|
|
|
|
2017-10-13 17:01:49 +08:00
|
|
|
writel(c, port->membase + UART_TSH(port));
|
2016-02-17 02:14:53 +08:00
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
static const struct uart_ops mvebu_uart_ops = {
|
|
|
|
|
.tx_empty = mvebu_uart_tx_empty,
|
|
|
|
|
.set_mctrl = mvebu_uart_set_mctrl,
|
|
|
|
|
.get_mctrl = mvebu_uart_get_mctrl,
|
|
|
|
|
.stop_tx = mvebu_uart_stop_tx,
|
|
|
|
|
.start_tx = mvebu_uart_start_tx,
|
|
|
|
|
.stop_rx = mvebu_uart_stop_rx,
|
|
|
|
|
.break_ctl = mvebu_uart_break_ctl,
|
|
|
|
|
.startup = mvebu_uart_startup,
|
|
|
|
|
.shutdown = mvebu_uart_shutdown,
|
|
|
|
|
.set_termios = mvebu_uart_set_termios,
|
|
|
|
|
.type = mvebu_uart_type,
|
|
|
|
|
.release_port = mvebu_uart_release_port,
|
|
|
|
|
.request_port = mvebu_uart_request_port,
|
|
|
|
|
#ifdef CONFIG_CONSOLE_POLL
|
|
|
|
|
.poll_get_char = mvebu_uart_get_poll_char,
|
|
|
|
|
.poll_put_char = mvebu_uart_put_poll_char,
|
|
|
|
|
#endif
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/* Console Driver Operations */
|
|
|
|
|
|
|
|
|
|
#ifdef CONFIG_SERIAL_MVEBU_CONSOLE
|
|
|
|
|
/* Early Console */
|
2022-03-03 16:08:31 +08:00
|
|
|
static void mvebu_uart_putc(struct uart_port *port, unsigned char c)
|
2016-02-17 02:14:53 +08:00
|
|
|
{
|
|
|
|
|
unsigned int st;
|
|
|
|
|
|
|
|
|
|
for (;;) {
|
|
|
|
|
st = readl(port->membase + UART_STAT);
|
|
|
|
|
if (!(st & STAT_TX_FIFO_FUL))
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
2017-10-13 17:01:49 +08:00
|
|
|
/* At early stage, DT is not parsed yet, only use UART0 */
|
|
|
|
|
writel(c, port->membase + UART_STD_TSH);
|
2016-02-17 02:14:53 +08:00
|
|
|
|
|
|
|
|
for (;;) {
|
|
|
|
|
st = readl(port->membase + UART_STAT);
|
|
|
|
|
if (st & STAT_TX_FIFO_EMP)
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void mvebu_uart_putc_early_write(struct console *con,
|
|
|
|
|
const char *s,
|
2021-06-24 10:12:07 +08:00
|
|
|
unsigned int n)
|
2016-02-17 02:14:53 +08:00
|
|
|
{
|
|
|
|
|
struct earlycon_device *dev = con->data;
|
|
|
|
|
|
|
|
|
|
uart_console_write(&dev->port, s, n, mvebu_uart_putc);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int __init
|
|
|
|
|
mvebu_uart_early_console_setup(struct earlycon_device *device,
|
|
|
|
|
const char *opt)
|
|
|
|
|
{
|
|
|
|
|
if (!device->port.membase)
|
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
|
|
device->con->write = mvebu_uart_putc_early_write;
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
EARLYCON_DECLARE(ar3700_uart, mvebu_uart_early_console_setup);
|
|
|
|
|
OF_EARLYCON_DECLARE(ar3700_uart, "marvell,armada-3700-uart",
|
|
|
|
|
mvebu_uart_early_console_setup);
|
|
|
|
|
|
|
|
|
|
static void wait_for_xmitr(struct uart_port *port)
|
|
|
|
|
{
|
|
|
|
|
u32 val;
|
|
|
|
|
|
|
|
|
|
readl_poll_timeout_atomic(port->membase + UART_STAT, val,
|
2018-03-23 03:15:12 +08:00
|
|
|
(val & STAT_TX_RDY(port)), 1, 10000);
|
2016-02-17 02:14:53 +08:00
|
|
|
}
|
|
|
|
|
|
2020-12-24 03:19:31 +08:00
|
|
|
static void wait_for_xmite(struct uart_port *port)
|
|
|
|
|
{
|
|
|
|
|
u32 val;
|
|
|
|
|
|
|
|
|
|
readl_poll_timeout_atomic(port->membase + UART_STAT, val,
|
|
|
|
|
(val & STAT_TX_EMP), 1, 10000);
|
|
|
|
|
}
|
|
|
|
|
|
2022-03-03 16:08:31 +08:00
|
|
|
static void mvebu_uart_console_putchar(struct uart_port *port, unsigned char ch)
|
2016-02-17 02:14:53 +08:00
|
|
|
{
|
|
|
|
|
wait_for_xmitr(port);
|
2017-10-13 17:01:49 +08:00
|
|
|
writel(ch, port->membase + UART_TSH(port));
|
2016-02-17 02:14:53 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void mvebu_uart_console_write(struct console *co, const char *s,
|
|
|
|
|
unsigned int count)
|
|
|
|
|
{
|
|
|
|
|
struct uart_port *port = &mvebu_uart_ports[co->index];
|
|
|
|
|
unsigned long flags;
|
2017-10-13 17:01:49 +08:00
|
|
|
unsigned int ier, intr, ctl;
|
2016-02-17 02:14:53 +08:00
|
|
|
int locked = 1;
|
|
|
|
|
|
|
|
|
|
if (oops_in_progress)
|
|
|
|
|
locked = spin_trylock_irqsave(&port->lock, flags);
|
|
|
|
|
else
|
|
|
|
|
spin_lock_irqsave(&port->lock, flags);
|
|
|
|
|
|
2017-10-13 17:01:49 +08:00
|
|
|
ier = readl(port->membase + UART_CTRL(port)) & CTRL_BRK_INT;
|
|
|
|
|
intr = readl(port->membase + UART_INTR(port)) &
|
|
|
|
|
(CTRL_RX_RDY_INT(port) | CTRL_TX_RDY_INT(port));
|
|
|
|
|
writel(0, port->membase + UART_CTRL(port));
|
|
|
|
|
writel(0, port->membase + UART_INTR(port));
|
2016-02-17 02:14:53 +08:00
|
|
|
|
|
|
|
|
uart_console_write(port, s, count, mvebu_uart_console_putchar);
|
|
|
|
|
|
2020-12-24 03:19:31 +08:00
|
|
|
wait_for_xmite(port);
|
2016-02-17 02:14:53 +08:00
|
|
|
|
|
|
|
|
if (ier)
|
2017-10-13 17:01:49 +08:00
|
|
|
writel(ier, port->membase + UART_CTRL(port));
|
|
|
|
|
|
|
|
|
|
if (intr) {
|
|
|
|
|
ctl = intr | readl(port->membase + UART_INTR(port));
|
|
|
|
|
writel(ctl, port->membase + UART_INTR(port));
|
|
|
|
|
}
|
2016-02-17 02:14:53 +08:00
|
|
|
|
|
|
|
|
if (locked)
|
|
|
|
|
spin_unlock_irqrestore(&port->lock, flags);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int mvebu_uart_console_setup(struct console *co, char *options)
|
|
|
|
|
{
|
|
|
|
|
struct uart_port *port;
|
|
|
|
|
int baud = 9600;
|
|
|
|
|
int bits = 8;
|
|
|
|
|
int parity = 'n';
|
|
|
|
|
int flow = 'n';
|
|
|
|
|
|
|
|
|
|
if (co->index < 0 || co->index >= MVEBU_NR_UARTS)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
|
|
port = &mvebu_uart_ports[co->index];
|
|
|
|
|
|
|
|
|
|
if (!port->mapbase || !port->membase) {
|
|
|
|
|
pr_debug("console on ttyMV%i not present\n", co->index);
|
|
|
|
|
return -ENODEV;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (options)
|
|
|
|
|
uart_parse_options(options, &baud, &parity, &bits, &flow);
|
|
|
|
|
|
|
|
|
|
return uart_set_options(port, co, baud, parity, bits, flow);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static struct uart_driver mvebu_uart_driver;
|
|
|
|
|
|
|
|
|
|
static struct console mvebu_uart_console = {
|
|
|
|
|
.name = "ttyMV",
|
|
|
|
|
.write = mvebu_uart_console_write,
|
|
|
|
|
.device = uart_console_device,
|
|
|
|
|
.setup = mvebu_uart_console_setup,
|
|
|
|
|
.flags = CON_PRINTBUFFER,
|
|
|
|
|
.index = -1,
|
|
|
|
|
.data = &mvebu_uart_driver,
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static int __init mvebu_uart_console_init(void)
|
|
|
|
|
{
|
|
|
|
|
register_console(&mvebu_uart_console);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
console_initcall(mvebu_uart_console_init);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#endif /* CONFIG_SERIAL_MVEBU_CONSOLE */
|
|
|
|
|
|
|
|
|
|
static struct uart_driver mvebu_uart_driver = {
|
|
|
|
|
.owner = THIS_MODULE,
|
2017-10-13 17:01:47 +08:00
|
|
|
.driver_name = DRIVER_NAME,
|
2016-02-17 02:14:53 +08:00
|
|
|
.dev_name = "ttyMV",
|
|
|
|
|
.nr = MVEBU_NR_UARTS,
|
|
|
|
|
#ifdef CONFIG_SERIAL_MVEBU_CONSOLE
|
|
|
|
|
.cons = &mvebu_uart_console,
|
|
|
|
|
#endif
|
|
|
|
|
};
|
|
|
|
|
|
2018-04-21 22:07:33 +08:00
|
|
|
#if defined(CONFIG_PM)
|
|
|
|
|
static int mvebu_uart_suspend(struct device *dev)
|
|
|
|
|
{
|
|
|
|
|
struct mvebu_uart *mvuart = dev_get_drvdata(dev);
|
|
|
|
|
struct uart_port *port = mvuart->port;
|
serial: mvebu-uart: implement UART clock driver for configuring UART base clock
Implement a new device driver for controlling UART clocks on Marvell
Armada 3700 SoC. This device driver is loaded for devices which match
the compatible string "marvell,armada-3700-uart-clock".
There are more pitfalls related to UART clocks:
- both UARTs use same parent clock source (which can be xtal or one of
the TBG clocks),
- if a TBG clock is used as the parent clock, there are two additional
divisors that can both be configured to divide the rate by 1, 2, ... 6,
but these divisors are again shared between the two UART controllers
on the SOC,
- the configuration of the parent clock source and divisors is done in
the address space of the first UART controller, UART1. Clocks can be
gated separately for UART1 and UART2, but this setting also lives in
the address space of UART1,
- Marvell's Functional Specification for Armada 3720 document has the
clock gating bits swapped, so the one described to gate UART1 clock
actually gates UART2 and vice versa,
- each UART has it's own "special divisor", and this uses the parent
clock described above. These divisors are configure in each UART's
address space separately.
Thus the driver for UART2 controller needs to have access to UART1
address space, since UART1 address space contains some bits exclusive
for UART2 and also some bits which are shared between UART1 and UART2.
Also, during boot, when early console is active on one of the UARTs,
and we want to switch parent clock from xtal (default) to TBG (to be
more flexible with baudrates), the driver changing UART clocks also
needs to be able to change the "special divisor", so that the baudrate
of earlycon is not changed when swtiching to normal console. Thus the
clock driver also needs to be able to access UART2 register space,
for UART2's "special divisor".
For these reasons, this new UART clock driver does not use
ioremap_resource(), but only ioremap() to prevent resource conflicts
between UART clock driver and UART driver.
We need to share only two 32-bit registers between the UART driver and
the UART clock driver:
- UART Clock Control
- UART 2 Baud Rate Divisor
Access to these two registers are protected by one spinlock to prevent
any conflicts. Access is required only during probing, when changing
baudrate or during suspend/resume.
Hardware can be configured to use one of following clocks as UART parent
clock: TBG-A-P, TBG-B-P, TBG-A-S, TBG-B-S, xtal. Not every clock is
usable for higher buadrates. Any subset can be specified in the
device-tree and the driver will choose the best one which also still
supports the mandatory baudrate of 9600 Bd. For smooth boot log output
it is needed to specify clock used by early console, otherwise garbage
would be printed on UART during probe of UART clock driver and
transitioning from early console to normal console.
We are implementing this to be able to configure TBG clock as UART
parent clock, which is required to be able to achieve higher baudrates
than 230400 Bd. We achieve this by referencing this new UART clock
device node in UART's device node. UART clock device driver
automatically chooses the best clock source for UART driver.
Until now, UART's device-tree node needed to reference one of the static
clocks (xtal or one of the TBGs) as parent clock in the `clocks`
phandle - the parent clock which was configured before booting the
kernel. If bootloader changed UART's parent clock, it needed to change
the `clocks` phandle in DTB correspondingly before booting.
From now on both the old mechanism (xtal or TBG referenced as parent
clock in `clocks` phandle) and the new one (UART clock referenced in the
`clocks` phandle) are supported, to provide full backward compatibility
with existing DTS files, full backward compatibility with existing boot
loaders, and to provide new features (runtime clock configuration to
allow higher baudrates than 230400 Bd). New features are available only
with new DTS files.
There was also a discussion about how the UART node and the
clock-controller node could be wrapped together in a new binding [1, 2].
As explained there, this is not possible if we want to keep backwards
compatibility with existing bootloaders, and thus we are doing this by
putting the UART clock-controller node inside the UART1 node.
[1] https://lore.kernel.org/linux-serial/20220120000651.in7s6nazif5qjkme@pali/
[2] https://lore.kernel.org/linux-serial/20220125204006.A6D09C340E0@smtp.kernel.org/
Reviewed-by: Marek Behún <kabel@kernel.org>
Reviewed-by: Stephen Boyd <sboyd@kernel.org>
Signed-off-by: Pali Rohár <pali@kernel.org>
Signed-off-by: Marek Behún <kabel@kernel.org>
Link: https://lore.kernel.org/r/20220219152818.4319-4-kabel@kernel.org
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2022-02-19 23:28:15 +08:00
|
|
|
unsigned long flags;
|
2018-04-21 22:07:33 +08:00
|
|
|
|
|
|
|
|
uart_suspend_port(&mvebu_uart_driver, port);
|
|
|
|
|
|
|
|
|
|
mvuart->pm_regs.rbr = readl(port->membase + UART_RBR(port));
|
|
|
|
|
mvuart->pm_regs.tsh = readl(port->membase + UART_TSH(port));
|
|
|
|
|
mvuart->pm_regs.ctrl = readl(port->membase + UART_CTRL(port));
|
|
|
|
|
mvuart->pm_regs.intr = readl(port->membase + UART_INTR(port));
|
|
|
|
|
mvuart->pm_regs.stat = readl(port->membase + UART_STAT);
|
serial: mvebu-uart: implement UART clock driver for configuring UART base clock
Implement a new device driver for controlling UART clocks on Marvell
Armada 3700 SoC. This device driver is loaded for devices which match
the compatible string "marvell,armada-3700-uart-clock".
There are more pitfalls related to UART clocks:
- both UARTs use same parent clock source (which can be xtal or one of
the TBG clocks),
- if a TBG clock is used as the parent clock, there are two additional
divisors that can both be configured to divide the rate by 1, 2, ... 6,
but these divisors are again shared between the two UART controllers
on the SOC,
- the configuration of the parent clock source and divisors is done in
the address space of the first UART controller, UART1. Clocks can be
gated separately for UART1 and UART2, but this setting also lives in
the address space of UART1,
- Marvell's Functional Specification for Armada 3720 document has the
clock gating bits swapped, so the one described to gate UART1 clock
actually gates UART2 and vice versa,
- each UART has it's own "special divisor", and this uses the parent
clock described above. These divisors are configure in each UART's
address space separately.
Thus the driver for UART2 controller needs to have access to UART1
address space, since UART1 address space contains some bits exclusive
for UART2 and also some bits which are shared between UART1 and UART2.
Also, during boot, when early console is active on one of the UARTs,
and we want to switch parent clock from xtal (default) to TBG (to be
more flexible with baudrates), the driver changing UART clocks also
needs to be able to change the "special divisor", so that the baudrate
of earlycon is not changed when swtiching to normal console. Thus the
clock driver also needs to be able to access UART2 register space,
for UART2's "special divisor".
For these reasons, this new UART clock driver does not use
ioremap_resource(), but only ioremap() to prevent resource conflicts
between UART clock driver and UART driver.
We need to share only two 32-bit registers between the UART driver and
the UART clock driver:
- UART Clock Control
- UART 2 Baud Rate Divisor
Access to these two registers are protected by one spinlock to prevent
any conflicts. Access is required only during probing, when changing
baudrate or during suspend/resume.
Hardware can be configured to use one of following clocks as UART parent
clock: TBG-A-P, TBG-B-P, TBG-A-S, TBG-B-S, xtal. Not every clock is
usable for higher buadrates. Any subset can be specified in the
device-tree and the driver will choose the best one which also still
supports the mandatory baudrate of 9600 Bd. For smooth boot log output
it is needed to specify clock used by early console, otherwise garbage
would be printed on UART during probe of UART clock driver and
transitioning from early console to normal console.
We are implementing this to be able to configure TBG clock as UART
parent clock, which is required to be able to achieve higher baudrates
than 230400 Bd. We achieve this by referencing this new UART clock
device node in UART's device node. UART clock device driver
automatically chooses the best clock source for UART driver.
Until now, UART's device-tree node needed to reference one of the static
clocks (xtal or one of the TBGs) as parent clock in the `clocks`
phandle - the parent clock which was configured before booting the
kernel. If bootloader changed UART's parent clock, it needed to change
the `clocks` phandle in DTB correspondingly before booting.
From now on both the old mechanism (xtal or TBG referenced as parent
clock in `clocks` phandle) and the new one (UART clock referenced in the
`clocks` phandle) are supported, to provide full backward compatibility
with existing DTS files, full backward compatibility with existing boot
loaders, and to provide new features (runtime clock configuration to
allow higher baudrates than 230400 Bd). New features are available only
with new DTS files.
There was also a discussion about how the UART node and the
clock-controller node could be wrapped together in a new binding [1, 2].
As explained there, this is not possible if we want to keep backwards
compatibility with existing bootloaders, and thus we are doing this by
putting the UART clock-controller node inside the UART1 node.
[1] https://lore.kernel.org/linux-serial/20220120000651.in7s6nazif5qjkme@pali/
[2] https://lore.kernel.org/linux-serial/20220125204006.A6D09C340E0@smtp.kernel.org/
Reviewed-by: Marek Behún <kabel@kernel.org>
Reviewed-by: Stephen Boyd <sboyd@kernel.org>
Signed-off-by: Pali Rohár <pali@kernel.org>
Signed-off-by: Marek Behún <kabel@kernel.org>
Link: https://lore.kernel.org/r/20220219152818.4319-4-kabel@kernel.org
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2022-02-19 23:28:15 +08:00
|
|
|
spin_lock_irqsave(&mvebu_uart_lock, flags);
|
2018-04-21 22:07:33 +08:00
|
|
|
mvuart->pm_regs.brdv = readl(port->membase + UART_BRDV);
|
serial: mvebu-uart: implement UART clock driver for configuring UART base clock
Implement a new device driver for controlling UART clocks on Marvell
Armada 3700 SoC. This device driver is loaded for devices which match
the compatible string "marvell,armada-3700-uart-clock".
There are more pitfalls related to UART clocks:
- both UARTs use same parent clock source (which can be xtal or one of
the TBG clocks),
- if a TBG clock is used as the parent clock, there are two additional
divisors that can both be configured to divide the rate by 1, 2, ... 6,
but these divisors are again shared between the two UART controllers
on the SOC,
- the configuration of the parent clock source and divisors is done in
the address space of the first UART controller, UART1. Clocks can be
gated separately for UART1 and UART2, but this setting also lives in
the address space of UART1,
- Marvell's Functional Specification for Armada 3720 document has the
clock gating bits swapped, so the one described to gate UART1 clock
actually gates UART2 and vice versa,
- each UART has it's own "special divisor", and this uses the parent
clock described above. These divisors are configure in each UART's
address space separately.
Thus the driver for UART2 controller needs to have access to UART1
address space, since UART1 address space contains some bits exclusive
for UART2 and also some bits which are shared between UART1 and UART2.
Also, during boot, when early console is active on one of the UARTs,
and we want to switch parent clock from xtal (default) to TBG (to be
more flexible with baudrates), the driver changing UART clocks also
needs to be able to change the "special divisor", so that the baudrate
of earlycon is not changed when swtiching to normal console. Thus the
clock driver also needs to be able to access UART2 register space,
for UART2's "special divisor".
For these reasons, this new UART clock driver does not use
ioremap_resource(), but only ioremap() to prevent resource conflicts
between UART clock driver and UART driver.
We need to share only two 32-bit registers between the UART driver and
the UART clock driver:
- UART Clock Control
- UART 2 Baud Rate Divisor
Access to these two registers are protected by one spinlock to prevent
any conflicts. Access is required only during probing, when changing
baudrate or during suspend/resume.
Hardware can be configured to use one of following clocks as UART parent
clock: TBG-A-P, TBG-B-P, TBG-A-S, TBG-B-S, xtal. Not every clock is
usable for higher buadrates. Any subset can be specified in the
device-tree and the driver will choose the best one which also still
supports the mandatory baudrate of 9600 Bd. For smooth boot log output
it is needed to specify clock used by early console, otherwise garbage
would be printed on UART during probe of UART clock driver and
transitioning from early console to normal console.
We are implementing this to be able to configure TBG clock as UART
parent clock, which is required to be able to achieve higher baudrates
than 230400 Bd. We achieve this by referencing this new UART clock
device node in UART's device node. UART clock device driver
automatically chooses the best clock source for UART driver.
Until now, UART's device-tree node needed to reference one of the static
clocks (xtal or one of the TBGs) as parent clock in the `clocks`
phandle - the parent clock which was configured before booting the
kernel. If bootloader changed UART's parent clock, it needed to change
the `clocks` phandle in DTB correspondingly before booting.
From now on both the old mechanism (xtal or TBG referenced as parent
clock in `clocks` phandle) and the new one (UART clock referenced in the
`clocks` phandle) are supported, to provide full backward compatibility
with existing DTS files, full backward compatibility with existing boot
loaders, and to provide new features (runtime clock configuration to
allow higher baudrates than 230400 Bd). New features are available only
with new DTS files.
There was also a discussion about how the UART node and the
clock-controller node could be wrapped together in a new binding [1, 2].
As explained there, this is not possible if we want to keep backwards
compatibility with existing bootloaders, and thus we are doing this by
putting the UART clock-controller node inside the UART1 node.
[1] https://lore.kernel.org/linux-serial/20220120000651.in7s6nazif5qjkme@pali/
[2] https://lore.kernel.org/linux-serial/20220125204006.A6D09C340E0@smtp.kernel.org/
Reviewed-by: Marek Behún <kabel@kernel.org>
Reviewed-by: Stephen Boyd <sboyd@kernel.org>
Signed-off-by: Pali Rohár <pali@kernel.org>
Signed-off-by: Marek Behún <kabel@kernel.org>
Link: https://lore.kernel.org/r/20220219152818.4319-4-kabel@kernel.org
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2022-02-19 23:28:15 +08:00
|
|
|
spin_unlock_irqrestore(&mvebu_uart_lock, flags);
|
2018-04-21 22:07:33 +08:00
|
|
|
mvuart->pm_regs.osamp = readl(port->membase + UART_OSAMP);
|
|
|
|
|
|
|
|
|
|
device_set_wakeup_enable(dev, true);
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int mvebu_uart_resume(struct device *dev)
|
|
|
|
|
{
|
|
|
|
|
struct mvebu_uart *mvuart = dev_get_drvdata(dev);
|
|
|
|
|
struct uart_port *port = mvuart->port;
|
serial: mvebu-uart: implement UART clock driver for configuring UART base clock
Implement a new device driver for controlling UART clocks on Marvell
Armada 3700 SoC. This device driver is loaded for devices which match
the compatible string "marvell,armada-3700-uart-clock".
There are more pitfalls related to UART clocks:
- both UARTs use same parent clock source (which can be xtal or one of
the TBG clocks),
- if a TBG clock is used as the parent clock, there are two additional
divisors that can both be configured to divide the rate by 1, 2, ... 6,
but these divisors are again shared between the two UART controllers
on the SOC,
- the configuration of the parent clock source and divisors is done in
the address space of the first UART controller, UART1. Clocks can be
gated separately for UART1 and UART2, but this setting also lives in
the address space of UART1,
- Marvell's Functional Specification for Armada 3720 document has the
clock gating bits swapped, so the one described to gate UART1 clock
actually gates UART2 and vice versa,
- each UART has it's own "special divisor", and this uses the parent
clock described above. These divisors are configure in each UART's
address space separately.
Thus the driver for UART2 controller needs to have access to UART1
address space, since UART1 address space contains some bits exclusive
for UART2 and also some bits which are shared between UART1 and UART2.
Also, during boot, when early console is active on one of the UARTs,
and we want to switch parent clock from xtal (default) to TBG (to be
more flexible with baudrates), the driver changing UART clocks also
needs to be able to change the "special divisor", so that the baudrate
of earlycon is not changed when swtiching to normal console. Thus the
clock driver also needs to be able to access UART2 register space,
for UART2's "special divisor".
For these reasons, this new UART clock driver does not use
ioremap_resource(), but only ioremap() to prevent resource conflicts
between UART clock driver and UART driver.
We need to share only two 32-bit registers between the UART driver and
the UART clock driver:
- UART Clock Control
- UART 2 Baud Rate Divisor
Access to these two registers are protected by one spinlock to prevent
any conflicts. Access is required only during probing, when changing
baudrate or during suspend/resume.
Hardware can be configured to use one of following clocks as UART parent
clock: TBG-A-P, TBG-B-P, TBG-A-S, TBG-B-S, xtal. Not every clock is
usable for higher buadrates. Any subset can be specified in the
device-tree and the driver will choose the best one which also still
supports the mandatory baudrate of 9600 Bd. For smooth boot log output
it is needed to specify clock used by early console, otherwise garbage
would be printed on UART during probe of UART clock driver and
transitioning from early console to normal console.
We are implementing this to be able to configure TBG clock as UART
parent clock, which is required to be able to achieve higher baudrates
than 230400 Bd. We achieve this by referencing this new UART clock
device node in UART's device node. UART clock device driver
automatically chooses the best clock source for UART driver.
Until now, UART's device-tree node needed to reference one of the static
clocks (xtal or one of the TBGs) as parent clock in the `clocks`
phandle - the parent clock which was configured before booting the
kernel. If bootloader changed UART's parent clock, it needed to change
the `clocks` phandle in DTB correspondingly before booting.
From now on both the old mechanism (xtal or TBG referenced as parent
clock in `clocks` phandle) and the new one (UART clock referenced in the
`clocks` phandle) are supported, to provide full backward compatibility
with existing DTS files, full backward compatibility with existing boot
loaders, and to provide new features (runtime clock configuration to
allow higher baudrates than 230400 Bd). New features are available only
with new DTS files.
There was also a discussion about how the UART node and the
clock-controller node could be wrapped together in a new binding [1, 2].
As explained there, this is not possible if we want to keep backwards
compatibility with existing bootloaders, and thus we are doing this by
putting the UART clock-controller node inside the UART1 node.
[1] https://lore.kernel.org/linux-serial/20220120000651.in7s6nazif5qjkme@pali/
[2] https://lore.kernel.org/linux-serial/20220125204006.A6D09C340E0@smtp.kernel.org/
Reviewed-by: Marek Behún <kabel@kernel.org>
Reviewed-by: Stephen Boyd <sboyd@kernel.org>
Signed-off-by: Pali Rohár <pali@kernel.org>
Signed-off-by: Marek Behún <kabel@kernel.org>
Link: https://lore.kernel.org/r/20220219152818.4319-4-kabel@kernel.org
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2022-02-19 23:28:15 +08:00
|
|
|
unsigned long flags;
|
2018-04-21 22:07:33 +08:00
|
|
|
|
|
|
|
|
writel(mvuart->pm_regs.rbr, port->membase + UART_RBR(port));
|
|
|
|
|
writel(mvuart->pm_regs.tsh, port->membase + UART_TSH(port));
|
|
|
|
|
writel(mvuart->pm_regs.ctrl, port->membase + UART_CTRL(port));
|
|
|
|
|
writel(mvuart->pm_regs.intr, port->membase + UART_INTR(port));
|
|
|
|
|
writel(mvuart->pm_regs.stat, port->membase + UART_STAT);
|
serial: mvebu-uart: implement UART clock driver for configuring UART base clock
Implement a new device driver for controlling UART clocks on Marvell
Armada 3700 SoC. This device driver is loaded for devices which match
the compatible string "marvell,armada-3700-uart-clock".
There are more pitfalls related to UART clocks:
- both UARTs use same parent clock source (which can be xtal or one of
the TBG clocks),
- if a TBG clock is used as the parent clock, there are two additional
divisors that can both be configured to divide the rate by 1, 2, ... 6,
but these divisors are again shared between the two UART controllers
on the SOC,
- the configuration of the parent clock source and divisors is done in
the address space of the first UART controller, UART1. Clocks can be
gated separately for UART1 and UART2, but this setting also lives in
the address space of UART1,
- Marvell's Functional Specification for Armada 3720 document has the
clock gating bits swapped, so the one described to gate UART1 clock
actually gates UART2 and vice versa,
- each UART has it's own "special divisor", and this uses the parent
clock described above. These divisors are configure in each UART's
address space separately.
Thus the driver for UART2 controller needs to have access to UART1
address space, since UART1 address space contains some bits exclusive
for UART2 and also some bits which are shared between UART1 and UART2.
Also, during boot, when early console is active on one of the UARTs,
and we want to switch parent clock from xtal (default) to TBG (to be
more flexible with baudrates), the driver changing UART clocks also
needs to be able to change the "special divisor", so that the baudrate
of earlycon is not changed when swtiching to normal console. Thus the
clock driver also needs to be able to access UART2 register space,
for UART2's "special divisor".
For these reasons, this new UART clock driver does not use
ioremap_resource(), but only ioremap() to prevent resource conflicts
between UART clock driver and UART driver.
We need to share only two 32-bit registers between the UART driver and
the UART clock driver:
- UART Clock Control
- UART 2 Baud Rate Divisor
Access to these two registers are protected by one spinlock to prevent
any conflicts. Access is required only during probing, when changing
baudrate or during suspend/resume.
Hardware can be configured to use one of following clocks as UART parent
clock: TBG-A-P, TBG-B-P, TBG-A-S, TBG-B-S, xtal. Not every clock is
usable for higher buadrates. Any subset can be specified in the
device-tree and the driver will choose the best one which also still
supports the mandatory baudrate of 9600 Bd. For smooth boot log output
it is needed to specify clock used by early console, otherwise garbage
would be printed on UART during probe of UART clock driver and
transitioning from early console to normal console.
We are implementing this to be able to configure TBG clock as UART
parent clock, which is required to be able to achieve higher baudrates
than 230400 Bd. We achieve this by referencing this new UART clock
device node in UART's device node. UART clock device driver
automatically chooses the best clock source for UART driver.
Until now, UART's device-tree node needed to reference one of the static
clocks (xtal or one of the TBGs) as parent clock in the `clocks`
phandle - the parent clock which was configured before booting the
kernel. If bootloader changed UART's parent clock, it needed to change
the `clocks` phandle in DTB correspondingly before booting.
From now on both the old mechanism (xtal or TBG referenced as parent
clock in `clocks` phandle) and the new one (UART clock referenced in the
`clocks` phandle) are supported, to provide full backward compatibility
with existing DTS files, full backward compatibility with existing boot
loaders, and to provide new features (runtime clock configuration to
allow higher baudrates than 230400 Bd). New features are available only
with new DTS files.
There was also a discussion about how the UART node and the
clock-controller node could be wrapped together in a new binding [1, 2].
As explained there, this is not possible if we want to keep backwards
compatibility with existing bootloaders, and thus we are doing this by
putting the UART clock-controller node inside the UART1 node.
[1] https://lore.kernel.org/linux-serial/20220120000651.in7s6nazif5qjkme@pali/
[2] https://lore.kernel.org/linux-serial/20220125204006.A6D09C340E0@smtp.kernel.org/
Reviewed-by: Marek Behún <kabel@kernel.org>
Reviewed-by: Stephen Boyd <sboyd@kernel.org>
Signed-off-by: Pali Rohár <pali@kernel.org>
Signed-off-by: Marek Behún <kabel@kernel.org>
Link: https://lore.kernel.org/r/20220219152818.4319-4-kabel@kernel.org
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2022-02-19 23:28:15 +08:00
|
|
|
spin_lock_irqsave(&mvebu_uart_lock, flags);
|
2018-04-21 22:07:33 +08:00
|
|
|
writel(mvuart->pm_regs.brdv, port->membase + UART_BRDV);
|
serial: mvebu-uart: implement UART clock driver for configuring UART base clock
Implement a new device driver for controlling UART clocks on Marvell
Armada 3700 SoC. This device driver is loaded for devices which match
the compatible string "marvell,armada-3700-uart-clock".
There are more pitfalls related to UART clocks:
- both UARTs use same parent clock source (which can be xtal or one of
the TBG clocks),
- if a TBG clock is used as the parent clock, there are two additional
divisors that can both be configured to divide the rate by 1, 2, ... 6,
but these divisors are again shared between the two UART controllers
on the SOC,
- the configuration of the parent clock source and divisors is done in
the address space of the first UART controller, UART1. Clocks can be
gated separately for UART1 and UART2, but this setting also lives in
the address space of UART1,
- Marvell's Functional Specification for Armada 3720 document has the
clock gating bits swapped, so the one described to gate UART1 clock
actually gates UART2 and vice versa,
- each UART has it's own "special divisor", and this uses the parent
clock described above. These divisors are configure in each UART's
address space separately.
Thus the driver for UART2 controller needs to have access to UART1
address space, since UART1 address space contains some bits exclusive
for UART2 and also some bits which are shared between UART1 and UART2.
Also, during boot, when early console is active on one of the UARTs,
and we want to switch parent clock from xtal (default) to TBG (to be
more flexible with baudrates), the driver changing UART clocks also
needs to be able to change the "special divisor", so that the baudrate
of earlycon is not changed when swtiching to normal console. Thus the
clock driver also needs to be able to access UART2 register space,
for UART2's "special divisor".
For these reasons, this new UART clock driver does not use
ioremap_resource(), but only ioremap() to prevent resource conflicts
between UART clock driver and UART driver.
We need to share only two 32-bit registers between the UART driver and
the UART clock driver:
- UART Clock Control
- UART 2 Baud Rate Divisor
Access to these two registers are protected by one spinlock to prevent
any conflicts. Access is required only during probing, when changing
baudrate or during suspend/resume.
Hardware can be configured to use one of following clocks as UART parent
clock: TBG-A-P, TBG-B-P, TBG-A-S, TBG-B-S, xtal. Not every clock is
usable for higher buadrates. Any subset can be specified in the
device-tree and the driver will choose the best one which also still
supports the mandatory baudrate of 9600 Bd. For smooth boot log output
it is needed to specify clock used by early console, otherwise garbage
would be printed on UART during probe of UART clock driver and
transitioning from early console to normal console.
We are implementing this to be able to configure TBG clock as UART
parent clock, which is required to be able to achieve higher baudrates
than 230400 Bd. We achieve this by referencing this new UART clock
device node in UART's device node. UART clock device driver
automatically chooses the best clock source for UART driver.
Until now, UART's device-tree node needed to reference one of the static
clocks (xtal or one of the TBGs) as parent clock in the `clocks`
phandle - the parent clock which was configured before booting the
kernel. If bootloader changed UART's parent clock, it needed to change
the `clocks` phandle in DTB correspondingly before booting.
From now on both the old mechanism (xtal or TBG referenced as parent
clock in `clocks` phandle) and the new one (UART clock referenced in the
`clocks` phandle) are supported, to provide full backward compatibility
with existing DTS files, full backward compatibility with existing boot
loaders, and to provide new features (runtime clock configuration to
allow higher baudrates than 230400 Bd). New features are available only
with new DTS files.
There was also a discussion about how the UART node and the
clock-controller node could be wrapped together in a new binding [1, 2].
As explained there, this is not possible if we want to keep backwards
compatibility with existing bootloaders, and thus we are doing this by
putting the UART clock-controller node inside the UART1 node.
[1] https://lore.kernel.org/linux-serial/20220120000651.in7s6nazif5qjkme@pali/
[2] https://lore.kernel.org/linux-serial/20220125204006.A6D09C340E0@smtp.kernel.org/
Reviewed-by: Marek Behún <kabel@kernel.org>
Reviewed-by: Stephen Boyd <sboyd@kernel.org>
Signed-off-by: Pali Rohár <pali@kernel.org>
Signed-off-by: Marek Behún <kabel@kernel.org>
Link: https://lore.kernel.org/r/20220219152818.4319-4-kabel@kernel.org
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2022-02-19 23:28:15 +08:00
|
|
|
spin_unlock_irqrestore(&mvebu_uart_lock, flags);
|
2018-04-21 22:07:33 +08:00
|
|
|
writel(mvuart->pm_regs.osamp, port->membase + UART_OSAMP);
|
|
|
|
|
|
|
|
|
|
uart_resume_port(&mvebu_uart_driver, port);
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static const struct dev_pm_ops mvebu_uart_pm_ops = {
|
|
|
|
|
.suspend = mvebu_uart_suspend,
|
|
|
|
|
.resume = mvebu_uart_resume,
|
|
|
|
|
};
|
|
|
|
|
#endif /* CONFIG_PM */
|
|
|
|
|
|
2017-10-13 17:01:49 +08:00
|
|
|
static const struct of_device_id mvebu_uart_of_match[];
|
|
|
|
|
|
2017-10-13 17:01:48 +08:00
|
|
|
/* Counter to keep track of each UART port id when not using CONFIG_OF */
|
|
|
|
|
static int uart_num_counter;
|
|
|
|
|
|
2016-02-17 02:14:53 +08:00
|
|
|
static int mvebu_uart_probe(struct platform_device *pdev)
|
|
|
|
|
{
|
|
|
|
|
struct resource *reg = platform_get_resource(pdev, IORESOURCE_MEM, 0);
|
2017-10-13 17:01:49 +08:00
|
|
|
const struct of_device_id *match = of_match_device(mvebu_uart_of_match,
|
|
|
|
|
&pdev->dev);
|
2016-02-17 02:14:53 +08:00
|
|
|
struct uart_port *port;
|
2017-10-13 17:01:49 +08:00
|
|
|
struct mvebu_uart *mvuart;
|
2020-09-29 16:56:51 +08:00
|
|
|
int id, irq;
|
2016-02-17 02:14:53 +08:00
|
|
|
|
2017-10-13 17:01:54 +08:00
|
|
|
if (!reg) {
|
|
|
|
|
dev_err(&pdev->dev, "no registers defined\n");
|
2016-02-17 02:14:53 +08:00
|
|
|
return -EINVAL;
|
|
|
|
|
}
|
|
|
|
|
|
2017-10-13 17:01:48 +08:00
|
|
|
/* Assume that all UART ports have a DT alias or none has */
|
|
|
|
|
id = of_alias_get_id(pdev->dev.of_node, "serial");
|
|
|
|
|
if (!pdev->dev.of_node || id < 0)
|
|
|
|
|
pdev->id = uart_num_counter++;
|
|
|
|
|
else
|
|
|
|
|
pdev->id = id;
|
|
|
|
|
|
|
|
|
|
if (pdev->id >= MVEBU_NR_UARTS) {
|
|
|
|
|
dev_err(&pdev->dev, "cannot have more than %d UART ports\n",
|
|
|
|
|
MVEBU_NR_UARTS);
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
port = &mvebu_uart_ports[pdev->id];
|
2016-02-17 02:14:53 +08:00
|
|
|
|
|
|
|
|
spin_lock_init(&port->lock);
|
|
|
|
|
|
|
|
|
|
port->dev = &pdev->dev;
|
|
|
|
|
port->type = PORT_MVEBU;
|
|
|
|
|
port->ops = &mvebu_uart_ops;
|
|
|
|
|
port->regshift = 0;
|
|
|
|
|
|
|
|
|
|
port->fifosize = 32;
|
|
|
|
|
port->iotype = UPIO_MEM32;
|
|
|
|
|
port->flags = UPF_FIXED_PORT;
|
2017-10-13 17:01:48 +08:00
|
|
|
port->line = pdev->id;
|
2016-02-17 02:14:53 +08:00
|
|
|
|
2017-10-13 17:01:54 +08:00
|
|
|
/*
|
|
|
|
|
* IRQ number is not stored in this structure because we may have two of
|
|
|
|
|
* them per port (RX and TX). Instead, use the driver UART structure
|
|
|
|
|
* array so called ->irq[].
|
|
|
|
|
*/
|
|
|
|
|
port->irq = 0;
|
2016-02-17 02:14:53 +08:00
|
|
|
port->irqflags = 0;
|
|
|
|
|
port->mapbase = reg->start;
|
|
|
|
|
|
|
|
|
|
port->membase = devm_ioremap_resource(&pdev->dev, reg);
|
|
|
|
|
if (IS_ERR(port->membase))
|
2020-03-05 09:38:23 +08:00
|
|
|
return PTR_ERR(port->membase);
|
2016-02-17 02:14:53 +08:00
|
|
|
|
2017-10-13 17:01:49 +08:00
|
|
|
mvuart = devm_kzalloc(&pdev->dev, sizeof(struct mvebu_uart),
|
|
|
|
|
GFP_KERNEL);
|
|
|
|
|
if (!mvuart)
|
2016-02-17 02:14:53 +08:00
|
|
|
return -ENOMEM;
|
|
|
|
|
|
2017-10-13 17:01:51 +08:00
|
|
|
/* Get controller data depending on the compatible string */
|
2017-10-13 17:01:49 +08:00
|
|
|
mvuart->data = (struct mvebu_uart_driver_data *)match->data;
|
|
|
|
|
mvuart->port = port;
|
2016-02-17 02:14:53 +08:00
|
|
|
|
2017-10-13 17:01:49 +08:00
|
|
|
port->private_data = mvuart;
|
|
|
|
|
platform_set_drvdata(pdev, mvuart);
|
2016-02-17 02:14:53 +08:00
|
|
|
|
2017-10-13 17:01:51 +08:00
|
|
|
/* Get fixed clock frequency */
|
|
|
|
|
mvuart->clk = devm_clk_get(&pdev->dev, NULL);
|
|
|
|
|
if (IS_ERR(mvuart->clk)) {
|
|
|
|
|
if (PTR_ERR(mvuart->clk) == -EPROBE_DEFER)
|
|
|
|
|
return PTR_ERR(mvuart->clk);
|
|
|
|
|
|
|
|
|
|
if (IS_EXTENDED(port)) {
|
|
|
|
|
dev_err(&pdev->dev, "unable to get UART clock\n");
|
|
|
|
|
return PTR_ERR(mvuart->clk);
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
if (!clk_prepare_enable(mvuart->clk))
|
|
|
|
|
port->uartclk = clk_get_rate(mvuart->clk);
|
|
|
|
|
}
|
|
|
|
|
|
2017-10-13 17:01:54 +08:00
|
|
|
/* Manage interrupts */
|
|
|
|
|
if (platform_irq_count(pdev) == 1) {
|
|
|
|
|
/* Old bindings: no name on the single unamed UART0 IRQ */
|
|
|
|
|
irq = platform_get_irq(pdev, 0);
|
2019-07-31 02:15:44 +08:00
|
|
|
if (irq < 0)
|
2017-10-13 17:01:54 +08:00
|
|
|
return irq;
|
|
|
|
|
|
|
|
|
|
mvuart->irq[UART_IRQ_SUM] = irq;
|
|
|
|
|
} else {
|
|
|
|
|
/*
|
|
|
|
|
* New bindings: named interrupts (RX, TX) for both UARTS,
|
|
|
|
|
* only make use of uart-rx and uart-tx interrupts, do not use
|
|
|
|
|
* uart-sum of UART0 port.
|
|
|
|
|
*/
|
|
|
|
|
irq = platform_get_irq_byname(pdev, "uart-rx");
|
2019-07-31 02:15:44 +08:00
|
|
|
if (irq < 0)
|
2017-10-13 17:01:54 +08:00
|
|
|
return irq;
|
|
|
|
|
|
|
|
|
|
mvuart->irq[UART_RX_IRQ] = irq;
|
|
|
|
|
|
|
|
|
|
irq = platform_get_irq_byname(pdev, "uart-tx");
|
2019-07-31 02:15:44 +08:00
|
|
|
if (irq < 0)
|
2017-10-13 17:01:54 +08:00
|
|
|
return irq;
|
|
|
|
|
|
|
|
|
|
mvuart->irq[UART_TX_IRQ] = irq;
|
|
|
|
|
}
|
|
|
|
|
|
2017-10-13 17:01:50 +08:00
|
|
|
/* UART Soft Reset*/
|
|
|
|
|
writel(CTRL_SOFT_RST, port->membase + UART_CTRL(port));
|
|
|
|
|
udelay(1);
|
|
|
|
|
writel(0, port->membase + UART_CTRL(port));
|
|
|
|
|
|
2020-09-21 21:11:05 +08:00
|
|
|
return uart_add_one_port(&mvebu_uart_driver, port);
|
2016-02-17 02:14:53 +08:00
|
|
|
}
|
|
|
|
|
|
2017-10-13 17:01:49 +08:00
|
|
|
static struct mvebu_uart_driver_data uart_std_driver_data = {
|
|
|
|
|
.is_ext = false,
|
|
|
|
|
.regs.rbr = UART_STD_RBR,
|
|
|
|
|
.regs.tsh = UART_STD_TSH,
|
|
|
|
|
.regs.ctrl = UART_STD_CTRL1,
|
|
|
|
|
.regs.intr = UART_STD_CTRL2,
|
|
|
|
|
.flags.ctrl_tx_rdy_int = CTRL_STD_TX_RDY_INT,
|
|
|
|
|
.flags.ctrl_rx_rdy_int = CTRL_STD_RX_RDY_INT,
|
|
|
|
|
.flags.stat_tx_rdy = STAT_STD_TX_RDY,
|
|
|
|
|
.flags.stat_rx_rdy = STAT_STD_RX_RDY,
|
|
|
|
|
};
|
|
|
|
|
|
2017-10-13 17:01:56 +08:00
|
|
|
static struct mvebu_uart_driver_data uart_ext_driver_data = {
|
|
|
|
|
.is_ext = true,
|
|
|
|
|
.regs.rbr = UART_EXT_RBR,
|
|
|
|
|
.regs.tsh = UART_EXT_TSH,
|
|
|
|
|
.regs.ctrl = UART_EXT_CTRL1,
|
|
|
|
|
.regs.intr = UART_EXT_CTRL2,
|
|
|
|
|
.flags.ctrl_tx_rdy_int = CTRL_EXT_TX_RDY_INT,
|
|
|
|
|
.flags.ctrl_rx_rdy_int = CTRL_EXT_RX_RDY_INT,
|
|
|
|
|
.flags.stat_tx_rdy = STAT_EXT_TX_RDY,
|
|
|
|
|
.flags.stat_rx_rdy = STAT_EXT_RX_RDY,
|
|
|
|
|
};
|
|
|
|
|
|
2016-02-17 02:14:53 +08:00
|
|
|
/* Match table for of_platform binding */
|
|
|
|
|
static const struct of_device_id mvebu_uart_of_match[] = {
|
2017-10-13 17:01:49 +08:00
|
|
|
{
|
|
|
|
|
.compatible = "marvell,armada-3700-uart",
|
|
|
|
|
.data = (void *)&uart_std_driver_data,
|
|
|
|
|
},
|
2017-10-13 17:01:56 +08:00
|
|
|
{
|
|
|
|
|
.compatible = "marvell,armada-3700-uart-ext",
|
|
|
|
|
.data = (void *)&uart_ext_driver_data,
|
|
|
|
|
},
|
2016-02-17 02:14:53 +08:00
|
|
|
{}
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static struct platform_driver mvebu_uart_platform_driver = {
|
|
|
|
|
.probe = mvebu_uart_probe,
|
|
|
|
|
.driver = {
|
|
|
|
|
.name = "mvebu-uart",
|
|
|
|
|
.of_match_table = of_match_ptr(mvebu_uart_of_match),
|
2016-03-14 07:48:52 +08:00
|
|
|
.suppress_bind_attrs = true,
|
2018-04-21 22:07:33 +08:00
|
|
|
#if defined(CONFIG_PM)
|
|
|
|
|
.pm = &mvebu_uart_pm_ops,
|
|
|
|
|
#endif /* CONFIG_PM */
|
2016-02-17 02:14:53 +08:00
|
|
|
},
|
|
|
|
|
};
|
|
|
|
|
|
serial: mvebu-uart: implement UART clock driver for configuring UART base clock
Implement a new device driver for controlling UART clocks on Marvell
Armada 3700 SoC. This device driver is loaded for devices which match
the compatible string "marvell,armada-3700-uart-clock".
There are more pitfalls related to UART clocks:
- both UARTs use same parent clock source (which can be xtal or one of
the TBG clocks),
- if a TBG clock is used as the parent clock, there are two additional
divisors that can both be configured to divide the rate by 1, 2, ... 6,
but these divisors are again shared between the two UART controllers
on the SOC,
- the configuration of the parent clock source and divisors is done in
the address space of the first UART controller, UART1. Clocks can be
gated separately for UART1 and UART2, but this setting also lives in
the address space of UART1,
- Marvell's Functional Specification for Armada 3720 document has the
clock gating bits swapped, so the one described to gate UART1 clock
actually gates UART2 and vice versa,
- each UART has it's own "special divisor", and this uses the parent
clock described above. These divisors are configure in each UART's
address space separately.
Thus the driver for UART2 controller needs to have access to UART1
address space, since UART1 address space contains some bits exclusive
for UART2 and also some bits which are shared between UART1 and UART2.
Also, during boot, when early console is active on one of the UARTs,
and we want to switch parent clock from xtal (default) to TBG (to be
more flexible with baudrates), the driver changing UART clocks also
needs to be able to change the "special divisor", so that the baudrate
of earlycon is not changed when swtiching to normal console. Thus the
clock driver also needs to be able to access UART2 register space,
for UART2's "special divisor".
For these reasons, this new UART clock driver does not use
ioremap_resource(), but only ioremap() to prevent resource conflicts
between UART clock driver and UART driver.
We need to share only two 32-bit registers between the UART driver and
the UART clock driver:
- UART Clock Control
- UART 2 Baud Rate Divisor
Access to these two registers are protected by one spinlock to prevent
any conflicts. Access is required only during probing, when changing
baudrate or during suspend/resume.
Hardware can be configured to use one of following clocks as UART parent
clock: TBG-A-P, TBG-B-P, TBG-A-S, TBG-B-S, xtal. Not every clock is
usable for higher buadrates. Any subset can be specified in the
device-tree and the driver will choose the best one which also still
supports the mandatory baudrate of 9600 Bd. For smooth boot log output
it is needed to specify clock used by early console, otherwise garbage
would be printed on UART during probe of UART clock driver and
transitioning from early console to normal console.
We are implementing this to be able to configure TBG clock as UART
parent clock, which is required to be able to achieve higher baudrates
than 230400 Bd. We achieve this by referencing this new UART clock
device node in UART's device node. UART clock device driver
automatically chooses the best clock source for UART driver.
Until now, UART's device-tree node needed to reference one of the static
clocks (xtal or one of the TBGs) as parent clock in the `clocks`
phandle - the parent clock which was configured before booting the
kernel. If bootloader changed UART's parent clock, it needed to change
the `clocks` phandle in DTB correspondingly before booting.
From now on both the old mechanism (xtal or TBG referenced as parent
clock in `clocks` phandle) and the new one (UART clock referenced in the
`clocks` phandle) are supported, to provide full backward compatibility
with existing DTS files, full backward compatibility with existing boot
loaders, and to provide new features (runtime clock configuration to
allow higher baudrates than 230400 Bd). New features are available only
with new DTS files.
There was also a discussion about how the UART node and the
clock-controller node could be wrapped together in a new binding [1, 2].
As explained there, this is not possible if we want to keep backwards
compatibility with existing bootloaders, and thus we are doing this by
putting the UART clock-controller node inside the UART1 node.
[1] https://lore.kernel.org/linux-serial/20220120000651.in7s6nazif5qjkme@pali/
[2] https://lore.kernel.org/linux-serial/20220125204006.A6D09C340E0@smtp.kernel.org/
Reviewed-by: Marek Behún <kabel@kernel.org>
Reviewed-by: Stephen Boyd <sboyd@kernel.org>
Signed-off-by: Pali Rohár <pali@kernel.org>
Signed-off-by: Marek Behún <kabel@kernel.org>
Link: https://lore.kernel.org/r/20220219152818.4319-4-kabel@kernel.org
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2022-02-19 23:28:15 +08:00
|
|
|
/* This code is based on clk-fixed-factor.c driver and modified. */
|
|
|
|
|
|
|
|
|
|
struct mvebu_uart_clock {
|
|
|
|
|
struct clk_hw clk_hw;
|
|
|
|
|
int clock_idx;
|
|
|
|
|
u32 pm_context_reg1;
|
|
|
|
|
u32 pm_context_reg2;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct mvebu_uart_clock_base {
|
|
|
|
|
struct mvebu_uart_clock clocks[2];
|
|
|
|
|
unsigned int parent_rates[5];
|
|
|
|
|
int parent_idx;
|
|
|
|
|
unsigned int div;
|
|
|
|
|
void __iomem *reg1;
|
|
|
|
|
void __iomem *reg2;
|
|
|
|
|
bool configured;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
#define PARENT_CLOCK_XTAL 4
|
|
|
|
|
|
|
|
|
|
#define to_uart_clock(hw) container_of(hw, struct mvebu_uart_clock, clk_hw)
|
|
|
|
|
#define to_uart_clock_base(uart_clock) container_of(uart_clock, \
|
|
|
|
|
struct mvebu_uart_clock_base, clocks[uart_clock->clock_idx])
|
|
|
|
|
|
|
|
|
|
static int mvebu_uart_clock_prepare(struct clk_hw *hw)
|
|
|
|
|
{
|
|
|
|
|
struct mvebu_uart_clock *uart_clock = to_uart_clock(hw);
|
|
|
|
|
struct mvebu_uart_clock_base *uart_clock_base =
|
|
|
|
|
to_uart_clock_base(uart_clock);
|
|
|
|
|
unsigned int prev_clock_idx, prev_clock_rate, prev_d1d2;
|
|
|
|
|
unsigned int parent_clock_idx, parent_clock_rate;
|
|
|
|
|
unsigned long flags;
|
|
|
|
|
unsigned int d1, d2;
|
|
|
|
|
u64 divisor;
|
|
|
|
|
u32 val;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* This function just reconfigures UART Clock Control register (located
|
|
|
|
|
* in UART1 address space which controls both UART1 and UART2) to
|
|
|
|
|
* selected UART base clock and recalculates current UART1/UART2
|
|
|
|
|
* divisors in their address spaces, so that final baudrate will not be
|
|
|
|
|
* changed by switching UART parent clock. This is required for
|
|
|
|
|
* otherwise kernel's boot log stops working - we need to ensure that
|
|
|
|
|
* UART baudrate does not change during this setup. It is a one time
|
|
|
|
|
* operation, it will execute only once and set `configured` to true,
|
|
|
|
|
* and be skipped on subsequent calls. Because this UART Clock Control
|
|
|
|
|
* register (UART_BRDV) is shared between UART1 baudrate function,
|
|
|
|
|
* UART1 clock selector and UART2 clock selector, every access to
|
|
|
|
|
* UART_BRDV (reg1) needs to be protected by a lock.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
spin_lock_irqsave(&mvebu_uart_lock, flags);
|
|
|
|
|
|
|
|
|
|
if (uart_clock_base->configured) {
|
|
|
|
|
spin_unlock_irqrestore(&mvebu_uart_lock, flags);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
parent_clock_idx = uart_clock_base->parent_idx;
|
|
|
|
|
parent_clock_rate = uart_clock_base->parent_rates[parent_clock_idx];
|
|
|
|
|
|
|
|
|
|
val = readl(uart_clock_base->reg1);
|
|
|
|
|
|
|
|
|
|
if (uart_clock_base->div > CLK_TBG_DIV1_MAX) {
|
|
|
|
|
d1 = CLK_TBG_DIV1_MAX;
|
|
|
|
|
d2 = uart_clock_base->div / CLK_TBG_DIV1_MAX;
|
|
|
|
|
} else {
|
|
|
|
|
d1 = uart_clock_base->div;
|
|
|
|
|
d2 = 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (val & CLK_NO_XTAL) {
|
|
|
|
|
prev_clock_idx = (val >> CLK_TBG_SEL_SHIFT) & CLK_TBG_SEL_MASK;
|
|
|
|
|
prev_d1d2 = ((val >> CLK_TBG_DIV1_SHIFT) & CLK_TBG_DIV1_MASK) *
|
|
|
|
|
((val >> CLK_TBG_DIV2_SHIFT) & CLK_TBG_DIV2_MASK);
|
|
|
|
|
} else {
|
|
|
|
|
prev_clock_idx = PARENT_CLOCK_XTAL;
|
|
|
|
|
prev_d1d2 = 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Note that uart_clock_base->parent_rates[i] may not be available */
|
|
|
|
|
prev_clock_rate = uart_clock_base->parent_rates[prev_clock_idx];
|
|
|
|
|
|
|
|
|
|
/* Recalculate UART1 divisor so UART1 baudrate does not change */
|
|
|
|
|
if (prev_clock_rate) {
|
|
|
|
|
divisor = DIV_U64_ROUND_CLOSEST((u64)(val & BRDV_BAUD_MASK) *
|
|
|
|
|
parent_clock_rate * prev_d1d2,
|
|
|
|
|
prev_clock_rate * d1 * d2);
|
|
|
|
|
if (divisor < 1)
|
|
|
|
|
divisor = 1;
|
|
|
|
|
else if (divisor > BRDV_BAUD_MAX)
|
|
|
|
|
divisor = BRDV_BAUD_MAX;
|
|
|
|
|
val = (val & ~BRDV_BAUD_MASK) | divisor;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (parent_clock_idx != PARENT_CLOCK_XTAL) {
|
|
|
|
|
/* Do not use XTAL, select TBG clock and TBG d1 * d2 divisors */
|
|
|
|
|
val |= CLK_NO_XTAL;
|
|
|
|
|
val &= ~(CLK_TBG_DIV1_MASK << CLK_TBG_DIV1_SHIFT);
|
|
|
|
|
val |= d1 << CLK_TBG_DIV1_SHIFT;
|
|
|
|
|
val &= ~(CLK_TBG_DIV2_MASK << CLK_TBG_DIV2_SHIFT);
|
|
|
|
|
val |= d2 << CLK_TBG_DIV2_SHIFT;
|
|
|
|
|
val &= ~(CLK_TBG_SEL_MASK << CLK_TBG_SEL_SHIFT);
|
|
|
|
|
val |= parent_clock_idx << CLK_TBG_SEL_SHIFT;
|
|
|
|
|
} else {
|
|
|
|
|
/* Use XTAL, TBG bits are then ignored */
|
|
|
|
|
val &= ~CLK_NO_XTAL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
writel(val, uart_clock_base->reg1);
|
|
|
|
|
|
|
|
|
|
/* Recalculate UART2 divisor so UART2 baudrate does not change */
|
|
|
|
|
if (prev_clock_rate) {
|
|
|
|
|
val = readl(uart_clock_base->reg2);
|
|
|
|
|
divisor = DIV_U64_ROUND_CLOSEST((u64)(val & BRDV_BAUD_MASK) *
|
|
|
|
|
parent_clock_rate * prev_d1d2,
|
|
|
|
|
prev_clock_rate * d1 * d2);
|
|
|
|
|
if (divisor < 1)
|
|
|
|
|
divisor = 1;
|
|
|
|
|
else if (divisor > BRDV_BAUD_MAX)
|
|
|
|
|
divisor = BRDV_BAUD_MAX;
|
|
|
|
|
val = (val & ~BRDV_BAUD_MASK) | divisor;
|
|
|
|
|
writel(val, uart_clock_base->reg2);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
uart_clock_base->configured = true;
|
|
|
|
|
|
|
|
|
|
spin_unlock_irqrestore(&mvebu_uart_lock, flags);
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int mvebu_uart_clock_enable(struct clk_hw *hw)
|
|
|
|
|
{
|
|
|
|
|
struct mvebu_uart_clock *uart_clock = to_uart_clock(hw);
|
|
|
|
|
struct mvebu_uart_clock_base *uart_clock_base =
|
|
|
|
|
to_uart_clock_base(uart_clock);
|
|
|
|
|
unsigned long flags;
|
|
|
|
|
u32 val;
|
|
|
|
|
|
|
|
|
|
spin_lock_irqsave(&mvebu_uart_lock, flags);
|
|
|
|
|
|
|
|
|
|
val = readl(uart_clock_base->reg1);
|
|
|
|
|
|
|
|
|
|
if (uart_clock->clock_idx == 0)
|
|
|
|
|
val &= ~UART1_CLK_DIS;
|
|
|
|
|
else
|
|
|
|
|
val &= ~UART2_CLK_DIS;
|
|
|
|
|
|
|
|
|
|
writel(val, uart_clock_base->reg1);
|
|
|
|
|
|
|
|
|
|
spin_unlock_irqrestore(&mvebu_uart_lock, flags);
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void mvebu_uart_clock_disable(struct clk_hw *hw)
|
|
|
|
|
{
|
|
|
|
|
struct mvebu_uart_clock *uart_clock = to_uart_clock(hw);
|
|
|
|
|
struct mvebu_uart_clock_base *uart_clock_base =
|
|
|
|
|
to_uart_clock_base(uart_clock);
|
|
|
|
|
unsigned long flags;
|
|
|
|
|
u32 val;
|
|
|
|
|
|
|
|
|
|
spin_lock_irqsave(&mvebu_uart_lock, flags);
|
|
|
|
|
|
|
|
|
|
val = readl(uart_clock_base->reg1);
|
|
|
|
|
|
|
|
|
|
if (uart_clock->clock_idx == 0)
|
|
|
|
|
val |= UART1_CLK_DIS;
|
|
|
|
|
else
|
|
|
|
|
val |= UART2_CLK_DIS;
|
|
|
|
|
|
|
|
|
|
writel(val, uart_clock_base->reg1);
|
|
|
|
|
|
|
|
|
|
spin_unlock_irqrestore(&mvebu_uart_lock, flags);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int mvebu_uart_clock_is_enabled(struct clk_hw *hw)
|
|
|
|
|
{
|
|
|
|
|
struct mvebu_uart_clock *uart_clock = to_uart_clock(hw);
|
|
|
|
|
struct mvebu_uart_clock_base *uart_clock_base =
|
|
|
|
|
to_uart_clock_base(uart_clock);
|
|
|
|
|
u32 val;
|
|
|
|
|
|
|
|
|
|
val = readl(uart_clock_base->reg1);
|
|
|
|
|
|
|
|
|
|
if (uart_clock->clock_idx == 0)
|
|
|
|
|
return !(val & UART1_CLK_DIS);
|
|
|
|
|
else
|
|
|
|
|
return !(val & UART2_CLK_DIS);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int mvebu_uart_clock_save_context(struct clk_hw *hw)
|
|
|
|
|
{
|
|
|
|
|
struct mvebu_uart_clock *uart_clock = to_uart_clock(hw);
|
|
|
|
|
struct mvebu_uart_clock_base *uart_clock_base =
|
|
|
|
|
to_uart_clock_base(uart_clock);
|
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
|
|
spin_lock_irqsave(&mvebu_uart_lock, flags);
|
|
|
|
|
uart_clock->pm_context_reg1 = readl(uart_clock_base->reg1);
|
|
|
|
|
uart_clock->pm_context_reg2 = readl(uart_clock_base->reg2);
|
|
|
|
|
spin_unlock_irqrestore(&mvebu_uart_lock, flags);
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void mvebu_uart_clock_restore_context(struct clk_hw *hw)
|
|
|
|
|
{
|
|
|
|
|
struct mvebu_uart_clock *uart_clock = to_uart_clock(hw);
|
|
|
|
|
struct mvebu_uart_clock_base *uart_clock_base =
|
|
|
|
|
to_uart_clock_base(uart_clock);
|
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
|
|
spin_lock_irqsave(&mvebu_uart_lock, flags);
|
|
|
|
|
writel(uart_clock->pm_context_reg1, uart_clock_base->reg1);
|
|
|
|
|
writel(uart_clock->pm_context_reg2, uart_clock_base->reg2);
|
|
|
|
|
spin_unlock_irqrestore(&mvebu_uart_lock, flags);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static unsigned long mvebu_uart_clock_recalc_rate(struct clk_hw *hw,
|
|
|
|
|
unsigned long parent_rate)
|
|
|
|
|
{
|
|
|
|
|
struct mvebu_uart_clock *uart_clock = to_uart_clock(hw);
|
|
|
|
|
struct mvebu_uart_clock_base *uart_clock_base =
|
|
|
|
|
to_uart_clock_base(uart_clock);
|
|
|
|
|
|
|
|
|
|
return parent_rate / uart_clock_base->div;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static long mvebu_uart_clock_round_rate(struct clk_hw *hw, unsigned long rate,
|
|
|
|
|
unsigned long *parent_rate)
|
|
|
|
|
{
|
|
|
|
|
struct mvebu_uart_clock *uart_clock = to_uart_clock(hw);
|
|
|
|
|
struct mvebu_uart_clock_base *uart_clock_base =
|
|
|
|
|
to_uart_clock_base(uart_clock);
|
|
|
|
|
|
|
|
|
|
return *parent_rate / uart_clock_base->div;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int mvebu_uart_clock_set_rate(struct clk_hw *hw, unsigned long rate,
|
|
|
|
|
unsigned long parent_rate)
|
|
|
|
|
{
|
|
|
|
|
/*
|
|
|
|
|
* We must report success but we can do so unconditionally because
|
|
|
|
|
* mvebu_uart_clock_round_rate returns values that ensure this call is a
|
|
|
|
|
* nop.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static const struct clk_ops mvebu_uart_clock_ops = {
|
|
|
|
|
.prepare = mvebu_uart_clock_prepare,
|
|
|
|
|
.enable = mvebu_uart_clock_enable,
|
|
|
|
|
.disable = mvebu_uart_clock_disable,
|
|
|
|
|
.is_enabled = mvebu_uart_clock_is_enabled,
|
|
|
|
|
.save_context = mvebu_uart_clock_save_context,
|
|
|
|
|
.restore_context = mvebu_uart_clock_restore_context,
|
|
|
|
|
.round_rate = mvebu_uart_clock_round_rate,
|
|
|
|
|
.set_rate = mvebu_uart_clock_set_rate,
|
|
|
|
|
.recalc_rate = mvebu_uart_clock_recalc_rate,
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static int mvebu_uart_clock_register(struct device *dev,
|
|
|
|
|
struct mvebu_uart_clock *uart_clock,
|
|
|
|
|
const char *name,
|
|
|
|
|
const char *parent_name)
|
|
|
|
|
{
|
|
|
|
|
struct clk_init_data init = { };
|
|
|
|
|
|
|
|
|
|
uart_clock->clk_hw.init = &init;
|
|
|
|
|
|
|
|
|
|
init.name = name;
|
|
|
|
|
init.ops = &mvebu_uart_clock_ops;
|
|
|
|
|
init.flags = 0;
|
|
|
|
|
init.num_parents = 1;
|
|
|
|
|
init.parent_names = &parent_name;
|
|
|
|
|
|
|
|
|
|
return devm_clk_hw_register(dev, &uart_clock->clk_hw);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int mvebu_uart_clock_probe(struct platform_device *pdev)
|
|
|
|
|
{
|
|
|
|
|
static const char *const uart_clk_names[] = { "uart_1", "uart_2" };
|
|
|
|
|
static const char *const parent_clk_names[] = { "TBG-A-P", "TBG-B-P",
|
|
|
|
|
"TBG-A-S", "TBG-B-S",
|
|
|
|
|
"xtal" };
|
|
|
|
|
struct clk *parent_clks[ARRAY_SIZE(parent_clk_names)];
|
|
|
|
|
struct mvebu_uart_clock_base *uart_clock_base;
|
|
|
|
|
struct clk_hw_onecell_data *hw_clk_data;
|
|
|
|
|
struct device *dev = &pdev->dev;
|
|
|
|
|
int i, parent_clk_idx, ret;
|
|
|
|
|
unsigned long div, rate;
|
|
|
|
|
struct resource *res;
|
|
|
|
|
unsigned int d1, d2;
|
|
|
|
|
|
|
|
|
|
BUILD_BUG_ON(ARRAY_SIZE(uart_clk_names) !=
|
|
|
|
|
ARRAY_SIZE(uart_clock_base->clocks));
|
|
|
|
|
BUILD_BUG_ON(ARRAY_SIZE(parent_clk_names) !=
|
|
|
|
|
ARRAY_SIZE(uart_clock_base->parent_rates));
|
|
|
|
|
|
|
|
|
|
uart_clock_base = devm_kzalloc(dev,
|
|
|
|
|
sizeof(*uart_clock_base),
|
|
|
|
|
GFP_KERNEL);
|
|
|
|
|
if (!uart_clock_base)
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
|
|
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
|
|
|
|
|
if (!res) {
|
|
|
|
|
dev_err(dev, "Couldn't get first register\n");
|
|
|
|
|
return -ENOENT;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* UART Clock Control register (reg1 / UART_BRDV) is in the address
|
|
|
|
|
* space of UART1 (standard UART variant), controls parent clock and
|
|
|
|
|
* dividers for both UART1 and UART2 and is supplied via DT as the first
|
|
|
|
|
* resource. Therefore use ioremap() rather than ioremap_resource() to
|
|
|
|
|
* avoid conflicts with UART1 driver. Access to UART_BRDV is protected
|
|
|
|
|
* by a lock shared between clock and UART driver.
|
|
|
|
|
*/
|
|
|
|
|
uart_clock_base->reg1 = devm_ioremap(dev, res->start,
|
|
|
|
|
resource_size(res));
|
2022-03-01 15:58:06 +08:00
|
|
|
if (!uart_clock_base->reg1)
|
|
|
|
|
return -ENOMEM;
|
serial: mvebu-uart: implement UART clock driver for configuring UART base clock
Implement a new device driver for controlling UART clocks on Marvell
Armada 3700 SoC. This device driver is loaded for devices which match
the compatible string "marvell,armada-3700-uart-clock".
There are more pitfalls related to UART clocks:
- both UARTs use same parent clock source (which can be xtal or one of
the TBG clocks),
- if a TBG clock is used as the parent clock, there are two additional
divisors that can both be configured to divide the rate by 1, 2, ... 6,
but these divisors are again shared between the two UART controllers
on the SOC,
- the configuration of the parent clock source and divisors is done in
the address space of the first UART controller, UART1. Clocks can be
gated separately for UART1 and UART2, but this setting also lives in
the address space of UART1,
- Marvell's Functional Specification for Armada 3720 document has the
clock gating bits swapped, so the one described to gate UART1 clock
actually gates UART2 and vice versa,
- each UART has it's own "special divisor", and this uses the parent
clock described above. These divisors are configure in each UART's
address space separately.
Thus the driver for UART2 controller needs to have access to UART1
address space, since UART1 address space contains some bits exclusive
for UART2 and also some bits which are shared between UART1 and UART2.
Also, during boot, when early console is active on one of the UARTs,
and we want to switch parent clock from xtal (default) to TBG (to be
more flexible with baudrates), the driver changing UART clocks also
needs to be able to change the "special divisor", so that the baudrate
of earlycon is not changed when swtiching to normal console. Thus the
clock driver also needs to be able to access UART2 register space,
for UART2's "special divisor".
For these reasons, this new UART clock driver does not use
ioremap_resource(), but only ioremap() to prevent resource conflicts
between UART clock driver and UART driver.
We need to share only two 32-bit registers between the UART driver and
the UART clock driver:
- UART Clock Control
- UART 2 Baud Rate Divisor
Access to these two registers are protected by one spinlock to prevent
any conflicts. Access is required only during probing, when changing
baudrate or during suspend/resume.
Hardware can be configured to use one of following clocks as UART parent
clock: TBG-A-P, TBG-B-P, TBG-A-S, TBG-B-S, xtal. Not every clock is
usable for higher buadrates. Any subset can be specified in the
device-tree and the driver will choose the best one which also still
supports the mandatory baudrate of 9600 Bd. For smooth boot log output
it is needed to specify clock used by early console, otherwise garbage
would be printed on UART during probe of UART clock driver and
transitioning from early console to normal console.
We are implementing this to be able to configure TBG clock as UART
parent clock, which is required to be able to achieve higher baudrates
than 230400 Bd. We achieve this by referencing this new UART clock
device node in UART's device node. UART clock device driver
automatically chooses the best clock source for UART driver.
Until now, UART's device-tree node needed to reference one of the static
clocks (xtal or one of the TBGs) as parent clock in the `clocks`
phandle - the parent clock which was configured before booting the
kernel. If bootloader changed UART's parent clock, it needed to change
the `clocks` phandle in DTB correspondingly before booting.
From now on both the old mechanism (xtal or TBG referenced as parent
clock in `clocks` phandle) and the new one (UART clock referenced in the
`clocks` phandle) are supported, to provide full backward compatibility
with existing DTS files, full backward compatibility with existing boot
loaders, and to provide new features (runtime clock configuration to
allow higher baudrates than 230400 Bd). New features are available only
with new DTS files.
There was also a discussion about how the UART node and the
clock-controller node could be wrapped together in a new binding [1, 2].
As explained there, this is not possible if we want to keep backwards
compatibility with existing bootloaders, and thus we are doing this by
putting the UART clock-controller node inside the UART1 node.
[1] https://lore.kernel.org/linux-serial/20220120000651.in7s6nazif5qjkme@pali/
[2] https://lore.kernel.org/linux-serial/20220125204006.A6D09C340E0@smtp.kernel.org/
Reviewed-by: Marek Behún <kabel@kernel.org>
Reviewed-by: Stephen Boyd <sboyd@kernel.org>
Signed-off-by: Pali Rohár <pali@kernel.org>
Signed-off-by: Marek Behún <kabel@kernel.org>
Link: https://lore.kernel.org/r/20220219152818.4319-4-kabel@kernel.org
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2022-02-19 23:28:15 +08:00
|
|
|
|
|
|
|
|
res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
|
|
|
|
|
if (!res) {
|
|
|
|
|
dev_err(dev, "Couldn't get second register\n");
|
|
|
|
|
return -ENOENT;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* UART 2 Baud Rate Divisor register (reg2 / UART_BRDV) is in address
|
|
|
|
|
* space of UART2 (extended UART variant), controls only one UART2
|
|
|
|
|
* specific divider and is supplied via DT as second resource.
|
|
|
|
|
* Therefore use ioremap() rather than ioremap_resource() to avoid
|
|
|
|
|
* conflicts with UART2 driver. Access to UART_BRDV is protected by a
|
|
|
|
|
* by lock shared between clock and UART driver.
|
|
|
|
|
*/
|
|
|
|
|
uart_clock_base->reg2 = devm_ioremap(dev, res->start,
|
|
|
|
|
resource_size(res));
|
2022-03-01 15:58:06 +08:00
|
|
|
if (!uart_clock_base->reg2)
|
|
|
|
|
return -ENOMEM;
|
serial: mvebu-uart: implement UART clock driver for configuring UART base clock
Implement a new device driver for controlling UART clocks on Marvell
Armada 3700 SoC. This device driver is loaded for devices which match
the compatible string "marvell,armada-3700-uart-clock".
There are more pitfalls related to UART clocks:
- both UARTs use same parent clock source (which can be xtal or one of
the TBG clocks),
- if a TBG clock is used as the parent clock, there are two additional
divisors that can both be configured to divide the rate by 1, 2, ... 6,
but these divisors are again shared between the two UART controllers
on the SOC,
- the configuration of the parent clock source and divisors is done in
the address space of the first UART controller, UART1. Clocks can be
gated separately for UART1 and UART2, but this setting also lives in
the address space of UART1,
- Marvell's Functional Specification for Armada 3720 document has the
clock gating bits swapped, so the one described to gate UART1 clock
actually gates UART2 and vice versa,
- each UART has it's own "special divisor", and this uses the parent
clock described above. These divisors are configure in each UART's
address space separately.
Thus the driver for UART2 controller needs to have access to UART1
address space, since UART1 address space contains some bits exclusive
for UART2 and also some bits which are shared between UART1 and UART2.
Also, during boot, when early console is active on one of the UARTs,
and we want to switch parent clock from xtal (default) to TBG (to be
more flexible with baudrates), the driver changing UART clocks also
needs to be able to change the "special divisor", so that the baudrate
of earlycon is not changed when swtiching to normal console. Thus the
clock driver also needs to be able to access UART2 register space,
for UART2's "special divisor".
For these reasons, this new UART clock driver does not use
ioremap_resource(), but only ioremap() to prevent resource conflicts
between UART clock driver and UART driver.
We need to share only two 32-bit registers between the UART driver and
the UART clock driver:
- UART Clock Control
- UART 2 Baud Rate Divisor
Access to these two registers are protected by one spinlock to prevent
any conflicts. Access is required only during probing, when changing
baudrate or during suspend/resume.
Hardware can be configured to use one of following clocks as UART parent
clock: TBG-A-P, TBG-B-P, TBG-A-S, TBG-B-S, xtal. Not every clock is
usable for higher buadrates. Any subset can be specified in the
device-tree and the driver will choose the best one which also still
supports the mandatory baudrate of 9600 Bd. For smooth boot log output
it is needed to specify clock used by early console, otherwise garbage
would be printed on UART during probe of UART clock driver and
transitioning from early console to normal console.
We are implementing this to be able to configure TBG clock as UART
parent clock, which is required to be able to achieve higher baudrates
than 230400 Bd. We achieve this by referencing this new UART clock
device node in UART's device node. UART clock device driver
automatically chooses the best clock source for UART driver.
Until now, UART's device-tree node needed to reference one of the static
clocks (xtal or one of the TBGs) as parent clock in the `clocks`
phandle - the parent clock which was configured before booting the
kernel. If bootloader changed UART's parent clock, it needed to change
the `clocks` phandle in DTB correspondingly before booting.
From now on both the old mechanism (xtal or TBG referenced as parent
clock in `clocks` phandle) and the new one (UART clock referenced in the
`clocks` phandle) are supported, to provide full backward compatibility
with existing DTS files, full backward compatibility with existing boot
loaders, and to provide new features (runtime clock configuration to
allow higher baudrates than 230400 Bd). New features are available only
with new DTS files.
There was also a discussion about how the UART node and the
clock-controller node could be wrapped together in a new binding [1, 2].
As explained there, this is not possible if we want to keep backwards
compatibility with existing bootloaders, and thus we are doing this by
putting the UART clock-controller node inside the UART1 node.
[1] https://lore.kernel.org/linux-serial/20220120000651.in7s6nazif5qjkme@pali/
[2] https://lore.kernel.org/linux-serial/20220125204006.A6D09C340E0@smtp.kernel.org/
Reviewed-by: Marek Behún <kabel@kernel.org>
Reviewed-by: Stephen Boyd <sboyd@kernel.org>
Signed-off-by: Pali Rohár <pali@kernel.org>
Signed-off-by: Marek Behún <kabel@kernel.org>
Link: https://lore.kernel.org/r/20220219152818.4319-4-kabel@kernel.org
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2022-02-19 23:28:15 +08:00
|
|
|
|
|
|
|
|
hw_clk_data = devm_kzalloc(dev,
|
|
|
|
|
struct_size(hw_clk_data, hws,
|
|
|
|
|
ARRAY_SIZE(uart_clk_names)),
|
|
|
|
|
GFP_KERNEL);
|
|
|
|
|
if (!hw_clk_data)
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
|
|
hw_clk_data->num = ARRAY_SIZE(uart_clk_names);
|
|
|
|
|
for (i = 0; i < ARRAY_SIZE(uart_clk_names); i++) {
|
|
|
|
|
hw_clk_data->hws[i] = &uart_clock_base->clocks[i].clk_hw;
|
|
|
|
|
uart_clock_base->clocks[i].clock_idx = i;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
parent_clk_idx = -1;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < ARRAY_SIZE(parent_clk_names); i++) {
|
|
|
|
|
parent_clks[i] = devm_clk_get(dev, parent_clk_names[i]);
|
|
|
|
|
if (IS_ERR(parent_clks[i])) {
|
|
|
|
|
if (PTR_ERR(parent_clks[i]) == -EPROBE_DEFER)
|
|
|
|
|
return -EPROBE_DEFER;
|
|
|
|
|
dev_warn(dev, "Couldn't get the parent clock %s: %ld\n",
|
|
|
|
|
parent_clk_names[i], PTR_ERR(parent_clks[i]));
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ret = clk_prepare_enable(parent_clks[i]);
|
|
|
|
|
if (ret) {
|
|
|
|
|
dev_warn(dev, "Couldn't enable parent clock %s: %d\n",
|
|
|
|
|
parent_clk_names[i], ret);
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
rate = clk_get_rate(parent_clks[i]);
|
|
|
|
|
uart_clock_base->parent_rates[i] = rate;
|
|
|
|
|
|
|
|
|
|
if (i != PARENT_CLOCK_XTAL) {
|
|
|
|
|
/*
|
|
|
|
|
* Calculate the smallest TBG d1 and d2 divisors that
|
|
|
|
|
* still can provide 9600 baudrate.
|
|
|
|
|
*/
|
2022-02-19 23:28:17 +08:00
|
|
|
d1 = DIV_ROUND_UP(rate, 9600 * OSAMP_MAX_DIVISOR *
|
serial: mvebu-uart: implement UART clock driver for configuring UART base clock
Implement a new device driver for controlling UART clocks on Marvell
Armada 3700 SoC. This device driver is loaded for devices which match
the compatible string "marvell,armada-3700-uart-clock".
There are more pitfalls related to UART clocks:
- both UARTs use same parent clock source (which can be xtal or one of
the TBG clocks),
- if a TBG clock is used as the parent clock, there are two additional
divisors that can both be configured to divide the rate by 1, 2, ... 6,
but these divisors are again shared between the two UART controllers
on the SOC,
- the configuration of the parent clock source and divisors is done in
the address space of the first UART controller, UART1. Clocks can be
gated separately for UART1 and UART2, but this setting also lives in
the address space of UART1,
- Marvell's Functional Specification for Armada 3720 document has the
clock gating bits swapped, so the one described to gate UART1 clock
actually gates UART2 and vice versa,
- each UART has it's own "special divisor", and this uses the parent
clock described above. These divisors are configure in each UART's
address space separately.
Thus the driver for UART2 controller needs to have access to UART1
address space, since UART1 address space contains some bits exclusive
for UART2 and also some bits which are shared between UART1 and UART2.
Also, during boot, when early console is active on one of the UARTs,
and we want to switch parent clock from xtal (default) to TBG (to be
more flexible with baudrates), the driver changing UART clocks also
needs to be able to change the "special divisor", so that the baudrate
of earlycon is not changed when swtiching to normal console. Thus the
clock driver also needs to be able to access UART2 register space,
for UART2's "special divisor".
For these reasons, this new UART clock driver does not use
ioremap_resource(), but only ioremap() to prevent resource conflicts
between UART clock driver and UART driver.
We need to share only two 32-bit registers between the UART driver and
the UART clock driver:
- UART Clock Control
- UART 2 Baud Rate Divisor
Access to these two registers are protected by one spinlock to prevent
any conflicts. Access is required only during probing, when changing
baudrate or during suspend/resume.
Hardware can be configured to use one of following clocks as UART parent
clock: TBG-A-P, TBG-B-P, TBG-A-S, TBG-B-S, xtal. Not every clock is
usable for higher buadrates. Any subset can be specified in the
device-tree and the driver will choose the best one which also still
supports the mandatory baudrate of 9600 Bd. For smooth boot log output
it is needed to specify clock used by early console, otherwise garbage
would be printed on UART during probe of UART clock driver and
transitioning from early console to normal console.
We are implementing this to be able to configure TBG clock as UART
parent clock, which is required to be able to achieve higher baudrates
than 230400 Bd. We achieve this by referencing this new UART clock
device node in UART's device node. UART clock device driver
automatically chooses the best clock source for UART driver.
Until now, UART's device-tree node needed to reference one of the static
clocks (xtal or one of the TBGs) as parent clock in the `clocks`
phandle - the parent clock which was configured before booting the
kernel. If bootloader changed UART's parent clock, it needed to change
the `clocks` phandle in DTB correspondingly before booting.
From now on both the old mechanism (xtal or TBG referenced as parent
clock in `clocks` phandle) and the new one (UART clock referenced in the
`clocks` phandle) are supported, to provide full backward compatibility
with existing DTS files, full backward compatibility with existing boot
loaders, and to provide new features (runtime clock configuration to
allow higher baudrates than 230400 Bd). New features are available only
with new DTS files.
There was also a discussion about how the UART node and the
clock-controller node could be wrapped together in a new binding [1, 2].
As explained there, this is not possible if we want to keep backwards
compatibility with existing bootloaders, and thus we are doing this by
putting the UART clock-controller node inside the UART1 node.
[1] https://lore.kernel.org/linux-serial/20220120000651.in7s6nazif5qjkme@pali/
[2] https://lore.kernel.org/linux-serial/20220125204006.A6D09C340E0@smtp.kernel.org/
Reviewed-by: Marek Behún <kabel@kernel.org>
Reviewed-by: Stephen Boyd <sboyd@kernel.org>
Signed-off-by: Pali Rohár <pali@kernel.org>
Signed-off-by: Marek Behún <kabel@kernel.org>
Link: https://lore.kernel.org/r/20220219152818.4319-4-kabel@kernel.org
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2022-02-19 23:28:15 +08:00
|
|
|
BRDV_BAUD_MAX);
|
|
|
|
|
if (d1 < 1)
|
|
|
|
|
d1 = 1;
|
|
|
|
|
else if (d1 > CLK_TBG_DIV1_MAX)
|
|
|
|
|
d1 = CLK_TBG_DIV1_MAX;
|
|
|
|
|
|
2022-02-19 23:28:17 +08:00
|
|
|
d2 = DIV_ROUND_UP(rate, 9600 * OSAMP_MAX_DIVISOR *
|
serial: mvebu-uart: implement UART clock driver for configuring UART base clock
Implement a new device driver for controlling UART clocks on Marvell
Armada 3700 SoC. This device driver is loaded for devices which match
the compatible string "marvell,armada-3700-uart-clock".
There are more pitfalls related to UART clocks:
- both UARTs use same parent clock source (which can be xtal or one of
the TBG clocks),
- if a TBG clock is used as the parent clock, there are two additional
divisors that can both be configured to divide the rate by 1, 2, ... 6,
but these divisors are again shared between the two UART controllers
on the SOC,
- the configuration of the parent clock source and divisors is done in
the address space of the first UART controller, UART1. Clocks can be
gated separately for UART1 and UART2, but this setting also lives in
the address space of UART1,
- Marvell's Functional Specification for Armada 3720 document has the
clock gating bits swapped, so the one described to gate UART1 clock
actually gates UART2 and vice versa,
- each UART has it's own "special divisor", and this uses the parent
clock described above. These divisors are configure in each UART's
address space separately.
Thus the driver for UART2 controller needs to have access to UART1
address space, since UART1 address space contains some bits exclusive
for UART2 and also some bits which are shared between UART1 and UART2.
Also, during boot, when early console is active on one of the UARTs,
and we want to switch parent clock from xtal (default) to TBG (to be
more flexible with baudrates), the driver changing UART clocks also
needs to be able to change the "special divisor", so that the baudrate
of earlycon is not changed when swtiching to normal console. Thus the
clock driver also needs to be able to access UART2 register space,
for UART2's "special divisor".
For these reasons, this new UART clock driver does not use
ioremap_resource(), but only ioremap() to prevent resource conflicts
between UART clock driver and UART driver.
We need to share only two 32-bit registers between the UART driver and
the UART clock driver:
- UART Clock Control
- UART 2 Baud Rate Divisor
Access to these two registers are protected by one spinlock to prevent
any conflicts. Access is required only during probing, when changing
baudrate or during suspend/resume.
Hardware can be configured to use one of following clocks as UART parent
clock: TBG-A-P, TBG-B-P, TBG-A-S, TBG-B-S, xtal. Not every clock is
usable for higher buadrates. Any subset can be specified in the
device-tree and the driver will choose the best one which also still
supports the mandatory baudrate of 9600 Bd. For smooth boot log output
it is needed to specify clock used by early console, otherwise garbage
would be printed on UART during probe of UART clock driver and
transitioning from early console to normal console.
We are implementing this to be able to configure TBG clock as UART
parent clock, which is required to be able to achieve higher baudrates
than 230400 Bd. We achieve this by referencing this new UART clock
device node in UART's device node. UART clock device driver
automatically chooses the best clock source for UART driver.
Until now, UART's device-tree node needed to reference one of the static
clocks (xtal or one of the TBGs) as parent clock in the `clocks`
phandle - the parent clock which was configured before booting the
kernel. If bootloader changed UART's parent clock, it needed to change
the `clocks` phandle in DTB correspondingly before booting.
From now on both the old mechanism (xtal or TBG referenced as parent
clock in `clocks` phandle) and the new one (UART clock referenced in the
`clocks` phandle) are supported, to provide full backward compatibility
with existing DTS files, full backward compatibility with existing boot
loaders, and to provide new features (runtime clock configuration to
allow higher baudrates than 230400 Bd). New features are available only
with new DTS files.
There was also a discussion about how the UART node and the
clock-controller node could be wrapped together in a new binding [1, 2].
As explained there, this is not possible if we want to keep backwards
compatibility with existing bootloaders, and thus we are doing this by
putting the UART clock-controller node inside the UART1 node.
[1] https://lore.kernel.org/linux-serial/20220120000651.in7s6nazif5qjkme@pali/
[2] https://lore.kernel.org/linux-serial/20220125204006.A6D09C340E0@smtp.kernel.org/
Reviewed-by: Marek Behún <kabel@kernel.org>
Reviewed-by: Stephen Boyd <sboyd@kernel.org>
Signed-off-by: Pali Rohár <pali@kernel.org>
Signed-off-by: Marek Behún <kabel@kernel.org>
Link: https://lore.kernel.org/r/20220219152818.4319-4-kabel@kernel.org
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2022-02-19 23:28:15 +08:00
|
|
|
BRDV_BAUD_MAX * d1);
|
|
|
|
|
if (d2 < 1)
|
|
|
|
|
d2 = 1;
|
|
|
|
|
else if (d2 > CLK_TBG_DIV2_MAX)
|
|
|
|
|
d2 = CLK_TBG_DIV2_MAX;
|
|
|
|
|
} else {
|
|
|
|
|
/*
|
|
|
|
|
* When UART clock uses XTAL clock as a source then it
|
|
|
|
|
* is not possible to use d1 and d2 divisors.
|
|
|
|
|
*/
|
|
|
|
|
d1 = d2 = 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Skip clock source which cannot provide 9600 baudrate */
|
2022-02-19 23:28:17 +08:00
|
|
|
if (rate > 9600 * OSAMP_MAX_DIVISOR * BRDV_BAUD_MAX * d1 * d2)
|
serial: mvebu-uart: implement UART clock driver for configuring UART base clock
Implement a new device driver for controlling UART clocks on Marvell
Armada 3700 SoC. This device driver is loaded for devices which match
the compatible string "marvell,armada-3700-uart-clock".
There are more pitfalls related to UART clocks:
- both UARTs use same parent clock source (which can be xtal or one of
the TBG clocks),
- if a TBG clock is used as the parent clock, there are two additional
divisors that can both be configured to divide the rate by 1, 2, ... 6,
but these divisors are again shared between the two UART controllers
on the SOC,
- the configuration of the parent clock source and divisors is done in
the address space of the first UART controller, UART1. Clocks can be
gated separately for UART1 and UART2, but this setting also lives in
the address space of UART1,
- Marvell's Functional Specification for Armada 3720 document has the
clock gating bits swapped, so the one described to gate UART1 clock
actually gates UART2 and vice versa,
- each UART has it's own "special divisor", and this uses the parent
clock described above. These divisors are configure in each UART's
address space separately.
Thus the driver for UART2 controller needs to have access to UART1
address space, since UART1 address space contains some bits exclusive
for UART2 and also some bits which are shared between UART1 and UART2.
Also, during boot, when early console is active on one of the UARTs,
and we want to switch parent clock from xtal (default) to TBG (to be
more flexible with baudrates), the driver changing UART clocks also
needs to be able to change the "special divisor", so that the baudrate
of earlycon is not changed when swtiching to normal console. Thus the
clock driver also needs to be able to access UART2 register space,
for UART2's "special divisor".
For these reasons, this new UART clock driver does not use
ioremap_resource(), but only ioremap() to prevent resource conflicts
between UART clock driver and UART driver.
We need to share only two 32-bit registers between the UART driver and
the UART clock driver:
- UART Clock Control
- UART 2 Baud Rate Divisor
Access to these two registers are protected by one spinlock to prevent
any conflicts. Access is required only during probing, when changing
baudrate or during suspend/resume.
Hardware can be configured to use one of following clocks as UART parent
clock: TBG-A-P, TBG-B-P, TBG-A-S, TBG-B-S, xtal. Not every clock is
usable for higher buadrates. Any subset can be specified in the
device-tree and the driver will choose the best one which also still
supports the mandatory baudrate of 9600 Bd. For smooth boot log output
it is needed to specify clock used by early console, otherwise garbage
would be printed on UART during probe of UART clock driver and
transitioning from early console to normal console.
We are implementing this to be able to configure TBG clock as UART
parent clock, which is required to be able to achieve higher baudrates
than 230400 Bd. We achieve this by referencing this new UART clock
device node in UART's device node. UART clock device driver
automatically chooses the best clock source for UART driver.
Until now, UART's device-tree node needed to reference one of the static
clocks (xtal or one of the TBGs) as parent clock in the `clocks`
phandle - the parent clock which was configured before booting the
kernel. If bootloader changed UART's parent clock, it needed to change
the `clocks` phandle in DTB correspondingly before booting.
From now on both the old mechanism (xtal or TBG referenced as parent
clock in `clocks` phandle) and the new one (UART clock referenced in the
`clocks` phandle) are supported, to provide full backward compatibility
with existing DTS files, full backward compatibility with existing boot
loaders, and to provide new features (runtime clock configuration to
allow higher baudrates than 230400 Bd). New features are available only
with new DTS files.
There was also a discussion about how the UART node and the
clock-controller node could be wrapped together in a new binding [1, 2].
As explained there, this is not possible if we want to keep backwards
compatibility with existing bootloaders, and thus we are doing this by
putting the UART clock-controller node inside the UART1 node.
[1] https://lore.kernel.org/linux-serial/20220120000651.in7s6nazif5qjkme@pali/
[2] https://lore.kernel.org/linux-serial/20220125204006.A6D09C340E0@smtp.kernel.org/
Reviewed-by: Marek Behún <kabel@kernel.org>
Reviewed-by: Stephen Boyd <sboyd@kernel.org>
Signed-off-by: Pali Rohár <pali@kernel.org>
Signed-off-by: Marek Behún <kabel@kernel.org>
Link: https://lore.kernel.org/r/20220219152818.4319-4-kabel@kernel.org
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2022-02-19 23:28:15 +08:00
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Choose TBG clock source with the smallest divisors. Use XTAL
|
|
|
|
|
* clock source only in case TBG is not available as XTAL cannot
|
|
|
|
|
* be used for baudrates higher than 230400.
|
|
|
|
|
*/
|
|
|
|
|
if (parent_clk_idx == -1 ||
|
|
|
|
|
(i != PARENT_CLOCK_XTAL && div > d1 * d2)) {
|
|
|
|
|
parent_clk_idx = i;
|
|
|
|
|
div = d1 * d2;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < ARRAY_SIZE(parent_clk_names); i++) {
|
|
|
|
|
if (i == parent_clk_idx || IS_ERR(parent_clks[i]))
|
|
|
|
|
continue;
|
|
|
|
|
clk_disable_unprepare(parent_clks[i]);
|
|
|
|
|
devm_clk_put(dev, parent_clks[i]);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (parent_clk_idx == -1) {
|
|
|
|
|
dev_err(dev, "No usable parent clock\n");
|
|
|
|
|
return -ENOENT;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
uart_clock_base->parent_idx = parent_clk_idx;
|
|
|
|
|
uart_clock_base->div = div;
|
|
|
|
|
|
|
|
|
|
dev_notice(dev, "Using parent clock %s as base UART clock\n",
|
|
|
|
|
__clk_get_name(parent_clks[parent_clk_idx]));
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < ARRAY_SIZE(uart_clk_names); i++) {
|
|
|
|
|
ret = mvebu_uart_clock_register(dev,
|
|
|
|
|
&uart_clock_base->clocks[i],
|
|
|
|
|
uart_clk_names[i],
|
|
|
|
|
__clk_get_name(parent_clks[parent_clk_idx]));
|
|
|
|
|
if (ret) {
|
|
|
|
|
dev_err(dev, "Can't register UART clock %d: %d\n",
|
|
|
|
|
i, ret);
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return devm_of_clk_add_hw_provider(dev, of_clk_hw_onecell_get,
|
|
|
|
|
hw_clk_data);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static const struct of_device_id mvebu_uart_clock_of_match[] = {
|
|
|
|
|
{ .compatible = "marvell,armada-3700-uart-clock", },
|
|
|
|
|
{ }
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static struct platform_driver mvebu_uart_clock_platform_driver = {
|
|
|
|
|
.probe = mvebu_uart_clock_probe,
|
|
|
|
|
.driver = {
|
|
|
|
|
.name = "mvebu-uart-clock",
|
|
|
|
|
.of_match_table = mvebu_uart_clock_of_match,
|
|
|
|
|
},
|
|
|
|
|
};
|
|
|
|
|
|
2016-02-17 02:14:53 +08:00
|
|
|
static int __init mvebu_uart_init(void)
|
|
|
|
|
{
|
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
|
|
ret = uart_register_driver(&mvebu_uart_driver);
|
|
|
|
|
if (ret)
|
|
|
|
|
return ret;
|
|
|
|
|
|
serial: mvebu-uart: implement UART clock driver for configuring UART base clock
Implement a new device driver for controlling UART clocks on Marvell
Armada 3700 SoC. This device driver is loaded for devices which match
the compatible string "marvell,armada-3700-uart-clock".
There are more pitfalls related to UART clocks:
- both UARTs use same parent clock source (which can be xtal or one of
the TBG clocks),
- if a TBG clock is used as the parent clock, there are two additional
divisors that can both be configured to divide the rate by 1, 2, ... 6,
but these divisors are again shared between the two UART controllers
on the SOC,
- the configuration of the parent clock source and divisors is done in
the address space of the first UART controller, UART1. Clocks can be
gated separately for UART1 and UART2, but this setting also lives in
the address space of UART1,
- Marvell's Functional Specification for Armada 3720 document has the
clock gating bits swapped, so the one described to gate UART1 clock
actually gates UART2 and vice versa,
- each UART has it's own "special divisor", and this uses the parent
clock described above. These divisors are configure in each UART's
address space separately.
Thus the driver for UART2 controller needs to have access to UART1
address space, since UART1 address space contains some bits exclusive
for UART2 and also some bits which are shared between UART1 and UART2.
Also, during boot, when early console is active on one of the UARTs,
and we want to switch parent clock from xtal (default) to TBG (to be
more flexible with baudrates), the driver changing UART clocks also
needs to be able to change the "special divisor", so that the baudrate
of earlycon is not changed when swtiching to normal console. Thus the
clock driver also needs to be able to access UART2 register space,
for UART2's "special divisor".
For these reasons, this new UART clock driver does not use
ioremap_resource(), but only ioremap() to prevent resource conflicts
between UART clock driver and UART driver.
We need to share only two 32-bit registers between the UART driver and
the UART clock driver:
- UART Clock Control
- UART 2 Baud Rate Divisor
Access to these two registers are protected by one spinlock to prevent
any conflicts. Access is required only during probing, when changing
baudrate or during suspend/resume.
Hardware can be configured to use one of following clocks as UART parent
clock: TBG-A-P, TBG-B-P, TBG-A-S, TBG-B-S, xtal. Not every clock is
usable for higher buadrates. Any subset can be specified in the
device-tree and the driver will choose the best one which also still
supports the mandatory baudrate of 9600 Bd. For smooth boot log output
it is needed to specify clock used by early console, otherwise garbage
would be printed on UART during probe of UART clock driver and
transitioning from early console to normal console.
We are implementing this to be able to configure TBG clock as UART
parent clock, which is required to be able to achieve higher baudrates
than 230400 Bd. We achieve this by referencing this new UART clock
device node in UART's device node. UART clock device driver
automatically chooses the best clock source for UART driver.
Until now, UART's device-tree node needed to reference one of the static
clocks (xtal or one of the TBGs) as parent clock in the `clocks`
phandle - the parent clock which was configured before booting the
kernel. If bootloader changed UART's parent clock, it needed to change
the `clocks` phandle in DTB correspondingly before booting.
From now on both the old mechanism (xtal or TBG referenced as parent
clock in `clocks` phandle) and the new one (UART clock referenced in the
`clocks` phandle) are supported, to provide full backward compatibility
with existing DTS files, full backward compatibility with existing boot
loaders, and to provide new features (runtime clock configuration to
allow higher baudrates than 230400 Bd). New features are available only
with new DTS files.
There was also a discussion about how the UART node and the
clock-controller node could be wrapped together in a new binding [1, 2].
As explained there, this is not possible if we want to keep backwards
compatibility with existing bootloaders, and thus we are doing this by
putting the UART clock-controller node inside the UART1 node.
[1] https://lore.kernel.org/linux-serial/20220120000651.in7s6nazif5qjkme@pali/
[2] https://lore.kernel.org/linux-serial/20220125204006.A6D09C340E0@smtp.kernel.org/
Reviewed-by: Marek Behún <kabel@kernel.org>
Reviewed-by: Stephen Boyd <sboyd@kernel.org>
Signed-off-by: Pali Rohár <pali@kernel.org>
Signed-off-by: Marek Behún <kabel@kernel.org>
Link: https://lore.kernel.org/r/20220219152818.4319-4-kabel@kernel.org
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2022-02-19 23:28:15 +08:00
|
|
|
ret = platform_driver_register(&mvebu_uart_clock_platform_driver);
|
|
|
|
|
if (ret) {
|
|
|
|
|
uart_unregister_driver(&mvebu_uart_driver);
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2016-02-17 02:14:53 +08:00
|
|
|
ret = platform_driver_register(&mvebu_uart_platform_driver);
|
serial: mvebu-uart: implement UART clock driver for configuring UART base clock
Implement a new device driver for controlling UART clocks on Marvell
Armada 3700 SoC. This device driver is loaded for devices which match
the compatible string "marvell,armada-3700-uart-clock".
There are more pitfalls related to UART clocks:
- both UARTs use same parent clock source (which can be xtal or one of
the TBG clocks),
- if a TBG clock is used as the parent clock, there are two additional
divisors that can both be configured to divide the rate by 1, 2, ... 6,
but these divisors are again shared between the two UART controllers
on the SOC,
- the configuration of the parent clock source and divisors is done in
the address space of the first UART controller, UART1. Clocks can be
gated separately for UART1 and UART2, but this setting also lives in
the address space of UART1,
- Marvell's Functional Specification for Armada 3720 document has the
clock gating bits swapped, so the one described to gate UART1 clock
actually gates UART2 and vice versa,
- each UART has it's own "special divisor", and this uses the parent
clock described above. These divisors are configure in each UART's
address space separately.
Thus the driver for UART2 controller needs to have access to UART1
address space, since UART1 address space contains some bits exclusive
for UART2 and also some bits which are shared between UART1 and UART2.
Also, during boot, when early console is active on one of the UARTs,
and we want to switch parent clock from xtal (default) to TBG (to be
more flexible with baudrates), the driver changing UART clocks also
needs to be able to change the "special divisor", so that the baudrate
of earlycon is not changed when swtiching to normal console. Thus the
clock driver also needs to be able to access UART2 register space,
for UART2's "special divisor".
For these reasons, this new UART clock driver does not use
ioremap_resource(), but only ioremap() to prevent resource conflicts
between UART clock driver and UART driver.
We need to share only two 32-bit registers between the UART driver and
the UART clock driver:
- UART Clock Control
- UART 2 Baud Rate Divisor
Access to these two registers are protected by one spinlock to prevent
any conflicts. Access is required only during probing, when changing
baudrate or during suspend/resume.
Hardware can be configured to use one of following clocks as UART parent
clock: TBG-A-P, TBG-B-P, TBG-A-S, TBG-B-S, xtal. Not every clock is
usable for higher buadrates. Any subset can be specified in the
device-tree and the driver will choose the best one which also still
supports the mandatory baudrate of 9600 Bd. For smooth boot log output
it is needed to specify clock used by early console, otherwise garbage
would be printed on UART during probe of UART clock driver and
transitioning from early console to normal console.
We are implementing this to be able to configure TBG clock as UART
parent clock, which is required to be able to achieve higher baudrates
than 230400 Bd. We achieve this by referencing this new UART clock
device node in UART's device node. UART clock device driver
automatically chooses the best clock source for UART driver.
Until now, UART's device-tree node needed to reference one of the static
clocks (xtal or one of the TBGs) as parent clock in the `clocks`
phandle - the parent clock which was configured before booting the
kernel. If bootloader changed UART's parent clock, it needed to change
the `clocks` phandle in DTB correspondingly before booting.
From now on both the old mechanism (xtal or TBG referenced as parent
clock in `clocks` phandle) and the new one (UART clock referenced in the
`clocks` phandle) are supported, to provide full backward compatibility
with existing DTS files, full backward compatibility with existing boot
loaders, and to provide new features (runtime clock configuration to
allow higher baudrates than 230400 Bd). New features are available only
with new DTS files.
There was also a discussion about how the UART node and the
clock-controller node could be wrapped together in a new binding [1, 2].
As explained there, this is not possible if we want to keep backwards
compatibility with existing bootloaders, and thus we are doing this by
putting the UART clock-controller node inside the UART1 node.
[1] https://lore.kernel.org/linux-serial/20220120000651.in7s6nazif5qjkme@pali/
[2] https://lore.kernel.org/linux-serial/20220125204006.A6D09C340E0@smtp.kernel.org/
Reviewed-by: Marek Behún <kabel@kernel.org>
Reviewed-by: Stephen Boyd <sboyd@kernel.org>
Signed-off-by: Pali Rohár <pali@kernel.org>
Signed-off-by: Marek Behún <kabel@kernel.org>
Link: https://lore.kernel.org/r/20220219152818.4319-4-kabel@kernel.org
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2022-02-19 23:28:15 +08:00
|
|
|
if (ret) {
|
|
|
|
|
platform_driver_unregister(&mvebu_uart_clock_platform_driver);
|
2016-02-17 02:14:53 +08:00
|
|
|
uart_unregister_driver(&mvebu_uart_driver);
|
serial: mvebu-uart: implement UART clock driver for configuring UART base clock
Implement a new device driver for controlling UART clocks on Marvell
Armada 3700 SoC. This device driver is loaded for devices which match
the compatible string "marvell,armada-3700-uart-clock".
There are more pitfalls related to UART clocks:
- both UARTs use same parent clock source (which can be xtal or one of
the TBG clocks),
- if a TBG clock is used as the parent clock, there are two additional
divisors that can both be configured to divide the rate by 1, 2, ... 6,
but these divisors are again shared between the two UART controllers
on the SOC,
- the configuration of the parent clock source and divisors is done in
the address space of the first UART controller, UART1. Clocks can be
gated separately for UART1 and UART2, but this setting also lives in
the address space of UART1,
- Marvell's Functional Specification for Armada 3720 document has the
clock gating bits swapped, so the one described to gate UART1 clock
actually gates UART2 and vice versa,
- each UART has it's own "special divisor", and this uses the parent
clock described above. These divisors are configure in each UART's
address space separately.
Thus the driver for UART2 controller needs to have access to UART1
address space, since UART1 address space contains some bits exclusive
for UART2 and also some bits which are shared between UART1 and UART2.
Also, during boot, when early console is active on one of the UARTs,
and we want to switch parent clock from xtal (default) to TBG (to be
more flexible with baudrates), the driver changing UART clocks also
needs to be able to change the "special divisor", so that the baudrate
of earlycon is not changed when swtiching to normal console. Thus the
clock driver also needs to be able to access UART2 register space,
for UART2's "special divisor".
For these reasons, this new UART clock driver does not use
ioremap_resource(), but only ioremap() to prevent resource conflicts
between UART clock driver and UART driver.
We need to share only two 32-bit registers between the UART driver and
the UART clock driver:
- UART Clock Control
- UART 2 Baud Rate Divisor
Access to these two registers are protected by one spinlock to prevent
any conflicts. Access is required only during probing, when changing
baudrate or during suspend/resume.
Hardware can be configured to use one of following clocks as UART parent
clock: TBG-A-P, TBG-B-P, TBG-A-S, TBG-B-S, xtal. Not every clock is
usable for higher buadrates. Any subset can be specified in the
device-tree and the driver will choose the best one which also still
supports the mandatory baudrate of 9600 Bd. For smooth boot log output
it is needed to specify clock used by early console, otherwise garbage
would be printed on UART during probe of UART clock driver and
transitioning from early console to normal console.
We are implementing this to be able to configure TBG clock as UART
parent clock, which is required to be able to achieve higher baudrates
than 230400 Bd. We achieve this by referencing this new UART clock
device node in UART's device node. UART clock device driver
automatically chooses the best clock source for UART driver.
Until now, UART's device-tree node needed to reference one of the static
clocks (xtal or one of the TBGs) as parent clock in the `clocks`
phandle - the parent clock which was configured before booting the
kernel. If bootloader changed UART's parent clock, it needed to change
the `clocks` phandle in DTB correspondingly before booting.
From now on both the old mechanism (xtal or TBG referenced as parent
clock in `clocks` phandle) and the new one (UART clock referenced in the
`clocks` phandle) are supported, to provide full backward compatibility
with existing DTS files, full backward compatibility with existing boot
loaders, and to provide new features (runtime clock configuration to
allow higher baudrates than 230400 Bd). New features are available only
with new DTS files.
There was also a discussion about how the UART node and the
clock-controller node could be wrapped together in a new binding [1, 2].
As explained there, this is not possible if we want to keep backwards
compatibility with existing bootloaders, and thus we are doing this by
putting the UART clock-controller node inside the UART1 node.
[1] https://lore.kernel.org/linux-serial/20220120000651.in7s6nazif5qjkme@pali/
[2] https://lore.kernel.org/linux-serial/20220125204006.A6D09C340E0@smtp.kernel.org/
Reviewed-by: Marek Behún <kabel@kernel.org>
Reviewed-by: Stephen Boyd <sboyd@kernel.org>
Signed-off-by: Pali Rohár <pali@kernel.org>
Signed-off-by: Marek Behún <kabel@kernel.org>
Link: https://lore.kernel.org/r/20220219152818.4319-4-kabel@kernel.org
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2022-02-19 23:28:15 +08:00
|
|
|
return ret;
|
|
|
|
|
}
|
2016-02-17 02:14:53 +08:00
|
|
|
|
serial: mvebu-uart: implement UART clock driver for configuring UART base clock
Implement a new device driver for controlling UART clocks on Marvell
Armada 3700 SoC. This device driver is loaded for devices which match
the compatible string "marvell,armada-3700-uart-clock".
There are more pitfalls related to UART clocks:
- both UARTs use same parent clock source (which can be xtal or one of
the TBG clocks),
- if a TBG clock is used as the parent clock, there are two additional
divisors that can both be configured to divide the rate by 1, 2, ... 6,
but these divisors are again shared between the two UART controllers
on the SOC,
- the configuration of the parent clock source and divisors is done in
the address space of the first UART controller, UART1. Clocks can be
gated separately for UART1 and UART2, but this setting also lives in
the address space of UART1,
- Marvell's Functional Specification for Armada 3720 document has the
clock gating bits swapped, so the one described to gate UART1 clock
actually gates UART2 and vice versa,
- each UART has it's own "special divisor", and this uses the parent
clock described above. These divisors are configure in each UART's
address space separately.
Thus the driver for UART2 controller needs to have access to UART1
address space, since UART1 address space contains some bits exclusive
for UART2 and also some bits which are shared between UART1 and UART2.
Also, during boot, when early console is active on one of the UARTs,
and we want to switch parent clock from xtal (default) to TBG (to be
more flexible with baudrates), the driver changing UART clocks also
needs to be able to change the "special divisor", so that the baudrate
of earlycon is not changed when swtiching to normal console. Thus the
clock driver also needs to be able to access UART2 register space,
for UART2's "special divisor".
For these reasons, this new UART clock driver does not use
ioremap_resource(), but only ioremap() to prevent resource conflicts
between UART clock driver and UART driver.
We need to share only two 32-bit registers between the UART driver and
the UART clock driver:
- UART Clock Control
- UART 2 Baud Rate Divisor
Access to these two registers are protected by one spinlock to prevent
any conflicts. Access is required only during probing, when changing
baudrate or during suspend/resume.
Hardware can be configured to use one of following clocks as UART parent
clock: TBG-A-P, TBG-B-P, TBG-A-S, TBG-B-S, xtal. Not every clock is
usable for higher buadrates. Any subset can be specified in the
device-tree and the driver will choose the best one which also still
supports the mandatory baudrate of 9600 Bd. For smooth boot log output
it is needed to specify clock used by early console, otherwise garbage
would be printed on UART during probe of UART clock driver and
transitioning from early console to normal console.
We are implementing this to be able to configure TBG clock as UART
parent clock, which is required to be able to achieve higher baudrates
than 230400 Bd. We achieve this by referencing this new UART clock
device node in UART's device node. UART clock device driver
automatically chooses the best clock source for UART driver.
Until now, UART's device-tree node needed to reference one of the static
clocks (xtal or one of the TBGs) as parent clock in the `clocks`
phandle - the parent clock which was configured before booting the
kernel. If bootloader changed UART's parent clock, it needed to change
the `clocks` phandle in DTB correspondingly before booting.
From now on both the old mechanism (xtal or TBG referenced as parent
clock in `clocks` phandle) and the new one (UART clock referenced in the
`clocks` phandle) are supported, to provide full backward compatibility
with existing DTS files, full backward compatibility with existing boot
loaders, and to provide new features (runtime clock configuration to
allow higher baudrates than 230400 Bd). New features are available only
with new DTS files.
There was also a discussion about how the UART node and the
clock-controller node could be wrapped together in a new binding [1, 2].
As explained there, this is not possible if we want to keep backwards
compatibility with existing bootloaders, and thus we are doing this by
putting the UART clock-controller node inside the UART1 node.
[1] https://lore.kernel.org/linux-serial/20220120000651.in7s6nazif5qjkme@pali/
[2] https://lore.kernel.org/linux-serial/20220125204006.A6D09C340E0@smtp.kernel.org/
Reviewed-by: Marek Behún <kabel@kernel.org>
Reviewed-by: Stephen Boyd <sboyd@kernel.org>
Signed-off-by: Pali Rohár <pali@kernel.org>
Signed-off-by: Marek Behún <kabel@kernel.org>
Link: https://lore.kernel.org/r/20220219152818.4319-4-kabel@kernel.org
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2022-02-19 23:28:15 +08:00
|
|
|
return 0;
|
2016-02-17 02:14:53 +08:00
|
|
|
}
|
|
|
|
|
arch_initcall(mvebu_uart_init);
|