Message ID | 20200320133452.3705040-3-thierry.reding@gmail.com |
---|---|
State | Deferred |
Headers | show |
Series | clocksource: Add NVIDIA Tegra186 timers support | expand |
20.03.2020 16:34, Thierry Reding пишет: > From: Thierry Reding <treding@nvidia.com> > > Currently this only supports a single watchdog, which uses a timer in > the background for countdown. Eventually the timers could be used for > various time-keeping tasks, but by default the architected timer will > already provide that functionality. > > Signed-off-by: Thierry Reding <treding@nvidia.com> > --- > drivers/clocksource/Kconfig | 8 + > drivers/clocksource/Makefile | 1 + > drivers/clocksource/timer-tegra186.c | 377 +++++++++++++++++++++++++++ > 3 files changed, 386 insertions(+) > create mode 100644 drivers/clocksource/timer-tegra186.c Hello Thierry, Shouldn't this driver reside in drivers/watchdog/? Like it's done in a case of the T30+ driver. ... > +static int __maybe_unused tegra186_timer_suspend(struct device *dev) > +{ > + return 0; > +} > + > +static int __maybe_unused tegra186_timer_resume(struct device *dev) > +{ > + return 0; > +} > + > +static SIMPLE_DEV_PM_OPS(tegra186_timer_pm_ops, tegra186_timer_suspend, > + tegra186_timer_resume); Perhaps will be better to remove these OPS for now?
On Fri, Mar 20, 2020 at 05:39:01PM +0300, Dmitry Osipenko wrote: > 20.03.2020 16:34, Thierry Reding пишет: > > From: Thierry Reding <treding@nvidia.com> > > > > Currently this only supports a single watchdog, which uses a timer in > > the background for countdown. Eventually the timers could be used for > > various time-keeping tasks, but by default the architected timer will > > already provide that functionality. > > > > Signed-off-by: Thierry Reding <treding@nvidia.com> > > --- > > drivers/clocksource/Kconfig | 8 + > > drivers/clocksource/Makefile | 1 + > > drivers/clocksource/timer-tegra186.c | 377 +++++++++++++++++++++++++++ > > 3 files changed, 386 insertions(+) > > create mode 100644 drivers/clocksource/timer-tegra186.c > Hello Thierry, > > Shouldn't this driver reside in drivers/watchdog/? Like it's done in a > case of the T30+ driver. The hardware block that this binds to is primarily a time-keeping block that just so happens to also implement a watchdog. Moving this to drivers/watchdog would put us into an odd situation if we ever added code to also implement the time-keeping bits for this hardware. I also think that the way this is done on Tegra30 was a bad choice. The problem is that we now have two drivers (tegra_wdt.c and tegra-timer.c) that both access the same region of memory. This seems to be relatively safe to do on those chips because there's no overlap between the timer and the watchdog interfaces, but on Tegra186 and later the watchdog is actually using one of the timers, so we'd have to be extra careful how to coordinate between the two. It seems much easier to do that by having everything in the same driver and have that register multiple devices in the system. > > +static int __maybe_unused tegra186_timer_suspend(struct device *dev) > > +{ > > + return 0; > > +} > > + > > +static int __maybe_unused tegra186_timer_resume(struct device *dev) > > +{ > > + return 0; > > +} > > + > > +static SIMPLE_DEV_PM_OPS(tegra186_timer_pm_ops, tegra186_timer_suspend, > > + tegra186_timer_resume); > > Perhaps will be better to remove these OPS for now? Yeah, I suppose I could remove those. Although... perhaps I should just try and make this work properly. Thierry
20.03.2020 16:34, Thierry Reding пишет: > From: Thierry Reding <treding@nvidia.com> > > Currently this only supports a single watchdog, which uses a timer in > the background for countdown. Eventually the timers could be used for > various time-keeping tasks, but by default the architected timer will > already provide that functionality. > > Signed-off-by: Thierry Reding <treding@nvidia.com> > --- ... > +config TEGRA186_TIMER > + bool "NVIDIA Tegra186 timer driver" tristate? > + depends on ARCH_TEGRA || COMPILE_TEST depends on WATCHDOG && WATCHDOG_CORE? > + select TIMER_OF > + help > + Enables support for the timers and watchdogs found on NVIDIA > + Tegra186 and later SoCs.
20.03.2020 18:04, Thierry Reding пишет: > On Fri, Mar 20, 2020 at 05:39:01PM +0300, Dmitry Osipenko wrote: >> 20.03.2020 16:34, Thierry Reding пишет: >>> From: Thierry Reding <treding@nvidia.com> >>> >>> Currently this only supports a single watchdog, which uses a timer in >>> the background for countdown. Eventually the timers could be used for >>> various time-keeping tasks, but by default the architected timer will >>> already provide that functionality. >>> >>> Signed-off-by: Thierry Reding <treding@nvidia.com> >>> --- >>> drivers/clocksource/Kconfig | 8 + >>> drivers/clocksource/Makefile | 1 + >>> drivers/clocksource/timer-tegra186.c | 377 +++++++++++++++++++++++++++ >>> 3 files changed, 386 insertions(+) >>> create mode 100644 drivers/clocksource/timer-tegra186.c >> Hello Thierry, >> >> Shouldn't this driver reside in drivers/watchdog/? Like it's done in a >> case of the T30+ driver. > > The hardware block that this binds to is primarily a time-keeping block > that just so happens to also implement a watchdog. Moving this to > drivers/watchdog would put us into an odd situation if we ever added > code to also implement the time-keeping bits for this hardware. > > I also think that the way this is done on Tegra30 was a bad choice. The > problem is that we now have two drivers (tegra_wdt.c and tegra-timer.c) > that both access the same region of memory. This seems to be relatively > safe to do on those chips because there's no overlap between the timer > and the watchdog interfaces, but on Tegra186 and later the watchdog is > actually using one of the timers, so we'd have to be extra careful how > to coordinate between the two. It seems much easier to do that by having > everything in the same driver and have that register multiple devices in > the system. Sounds like a watchdog on Tegra20, where one of the timer is shared with a watchdog function and there are no other free timers. Well, yes, it's not nice. But, will you really ever need an additional clocksource on T186?
20.03.2020 18:11, Dmitry Osipenko пишет: > 20.03.2020 16:34, Thierry Reding пишет: >> From: Thierry Reding <treding@nvidia.com> >> >> Currently this only supports a single watchdog, which uses a timer in >> the background for countdown. Eventually the timers could be used for >> various time-keeping tasks, but by default the architected timer will >> already provide that functionality. >> >> Signed-off-by: Thierry Reding <treding@nvidia.com> >> --- > > ... >> +config TEGRA186_TIMER >> + bool "NVIDIA Tegra186 timer driver" > > tristate? > >> + depends on ARCH_TEGRA || COMPILE_TEST > > depends on WATCHDOG && WATCHDOG_CORE? Actually `select WATCHDOG_CORE` for the WATCHDOG_CORE.
On Fri, Mar 20, 2020 at 06:23:35PM +0300, Dmitry Osipenko wrote: > 20.03.2020 18:04, Thierry Reding пишет: > > On Fri, Mar 20, 2020 at 05:39:01PM +0300, Dmitry Osipenko wrote: > >> 20.03.2020 16:34, Thierry Reding пишет: > >>> From: Thierry Reding <treding@nvidia.com> > >>> > >>> Currently this only supports a single watchdog, which uses a timer in > >>> the background for countdown. Eventually the timers could be used for > >>> various time-keeping tasks, but by default the architected timer will > >>> already provide that functionality. > >>> > >>> Signed-off-by: Thierry Reding <treding@nvidia.com> > >>> --- > >>> drivers/clocksource/Kconfig | 8 + > >>> drivers/clocksource/Makefile | 1 + > >>> drivers/clocksource/timer-tegra186.c | 377 +++++++++++++++++++++++++++ > >>> 3 files changed, 386 insertions(+) > >>> create mode 100644 drivers/clocksource/timer-tegra186.c > >> Hello Thierry, > >> > >> Shouldn't this driver reside in drivers/watchdog/? Like it's done in a > >> case of the T30+ driver. > > > > The hardware block that this binds to is primarily a time-keeping block > > that just so happens to also implement a watchdog. Moving this to > > drivers/watchdog would put us into an odd situation if we ever added > > code to also implement the time-keeping bits for this hardware. > > > > I also think that the way this is done on Tegra30 was a bad choice. The > > problem is that we now have two drivers (tegra_wdt.c and tegra-timer.c) > > that both access the same region of memory. This seems to be relatively > > safe to do on those chips because there's no overlap between the timer > > and the watchdog interfaces, but on Tegra186 and later the watchdog is > > actually using one of the timers, so we'd have to be extra careful how > > to coordinate between the two. It seems much easier to do that by having > > everything in the same driver and have that register multiple devices in > > the system. > > Sounds like a watchdog on Tegra20, where one of the timer is shared with > a watchdog function and there are no other free timers. Well, yes, it's > not nice. > > But, will you really ever need an additional clocksource on T186? I don't know. It's possible that they will become useful at some point. Thierry
On Fri, Mar 20, 2020 at 06:38:32PM +0300, Dmitry Osipenko wrote: > 20.03.2020 18:11, Dmitry Osipenko пишет: > > 20.03.2020 16:34, Thierry Reding пишет: > >> From: Thierry Reding <treding@nvidia.com> > >> > >> Currently this only supports a single watchdog, which uses a timer in > >> the background for countdown. Eventually the timers could be used for > >> various time-keeping tasks, but by default the architected timer will > >> already provide that functionality. > >> > >> Signed-off-by: Thierry Reding <treding@nvidia.com> > >> --- > > > > ... > >> +config TEGRA186_TIMER > >> + bool "NVIDIA Tegra186 timer driver" > > > > tristate? > > > >> + depends on ARCH_TEGRA || COMPILE_TEST > > > > depends on WATCHDOG && WATCHDOG_CORE? > > Actually `select WATCHDOG_CORE` for the WATCHDOG_CORE. WATCHDOG_CORE is user-visible, so it's not safe to select it. Any reason depends on WATCHDOG && WATCHDOG_CORE wouldn't work? I guess a dependency on WATCHDOG_CORE would be enough because that itself already depends on WATCHDOG. Thierry
23.03.2020 16:42, Thierry Reding пишет: > On Fri, Mar 20, 2020 at 06:38:32PM +0300, Dmitry Osipenko wrote: >> 20.03.2020 18:11, Dmitry Osipenko пишет: >>> 20.03.2020 16:34, Thierry Reding пишет: >>>> From: Thierry Reding <treding@nvidia.com> >>>> >>>> Currently this only supports a single watchdog, which uses a timer in >>>> the background for countdown. Eventually the timers could be used for >>>> various time-keeping tasks, but by default the architected timer will >>>> already provide that functionality. >>>> >>>> Signed-off-by: Thierry Reding <treding@nvidia.com> >>>> --- >>> >>> ... >>>> +config TEGRA186_TIMER >>>> + bool "NVIDIA Tegra186 timer driver" >>> >>> tristate? >>> >>>> + depends on ARCH_TEGRA || COMPILE_TEST >>> >>> depends on WATCHDOG && WATCHDOG_CORE? >> >> Actually `select WATCHDOG_CORE` for the WATCHDOG_CORE. > > WATCHDOG_CORE is user-visible, so it's not safe to select it. Any reason > depends on WATCHDOG && WATCHDOG_CORE wouldn't work? I guess a dependency > on WATCHDOG_CORE would be enough because that itself already depends on > WATCHDOG. It looks to that should be much better if you could factor out all the watchdog functionality into the drivers/watchdog, like it's done in a case of MC / SMMU drivers for example.
23.03.2020 16:45, Dmitry Osipenko пишет: > 23.03.2020 16:42, Thierry Reding пишет: >> On Fri, Mar 20, 2020 at 06:38:32PM +0300, Dmitry Osipenko wrote: >>> 20.03.2020 18:11, Dmitry Osipenko пишет: >>>> 20.03.2020 16:34, Thierry Reding пишет: >>>>> From: Thierry Reding <treding@nvidia.com> >>>>> >>>>> Currently this only supports a single watchdog, which uses a timer in >>>>> the background for countdown. Eventually the timers could be used for >>>>> various time-keeping tasks, but by default the architected timer will >>>>> already provide that functionality. >>>>> >>>>> Signed-off-by: Thierry Reding <treding@nvidia.com> >>>>> --- >>>> >>>> ... >>>>> +config TEGRA186_TIMER >>>>> + bool "NVIDIA Tegra186 timer driver" >>>> >>>> tristate? >>>> >>>>> + depends on ARCH_TEGRA || COMPILE_TEST >>>> >>>> depends on WATCHDOG && WATCHDOG_CORE? >>> >>> Actually `select WATCHDOG_CORE` for the WATCHDOG_CORE. >> >> WATCHDOG_CORE is user-visible, so it's not safe to select it. Any reason >> depends on WATCHDOG && WATCHDOG_CORE wouldn't work? I guess a dependency >> on WATCHDOG_CORE would be enough because that itself already depends on >> WATCHDOG. > > It looks to that should be much better if you could factor out all the > watchdog functionality into the drivers/watchdog, like it's done in a > case of MC / SMMU drivers for example. Also, please see drivers/watchdog/Kconfig where each individual driver selects WATCHDOG_CORE on by as-needed basis.
On Mon, Mar 23, 2020 at 04:45:57PM +0300, Dmitry Osipenko wrote: > 23.03.2020 16:42, Thierry Reding пишет: > > On Fri, Mar 20, 2020 at 06:38:32PM +0300, Dmitry Osipenko wrote: > >> 20.03.2020 18:11, Dmitry Osipenko пишет: > >>> 20.03.2020 16:34, Thierry Reding пишет: > >>>> From: Thierry Reding <treding@nvidia.com> > >>>> > >>>> Currently this only supports a single watchdog, which uses a timer in > >>>> the background for countdown. Eventually the timers could be used for > >>>> various time-keeping tasks, but by default the architected timer will > >>>> already provide that functionality. > >>>> > >>>> Signed-off-by: Thierry Reding <treding@nvidia.com> > >>>> --- > >>> > >>> ... > >>>> +config TEGRA186_TIMER > >>>> + bool "NVIDIA Tegra186 timer driver" > >>> > >>> tristate? > >>> > >>>> + depends on ARCH_TEGRA || COMPILE_TEST > >>> > >>> depends on WATCHDOG && WATCHDOG_CORE? > >> > >> Actually `select WATCHDOG_CORE` for the WATCHDOG_CORE. > > > > WATCHDOG_CORE is user-visible, so it's not safe to select it. Any reason > > depends on WATCHDOG && WATCHDOG_CORE wouldn't work? I guess a dependency > > on WATCHDOG_CORE would be enough because that itself already depends on > > WATCHDOG. > > It looks to that should be much better if you could factor out all the > watchdog functionality into the drivers/watchdog, like it's done in a > case of MC / SMMU drivers for example. For MC/SMMU this was done for historical reasons. Both drivers already existed in the respective subdirectories, so it seemed best to keep them there in order to avoid churn. This being a completely new driver I don't think the same argument can be made. There are plenty of drivers that register interfaces for multiple subsystems (e.g. there are a couple of watchdog drivers in the RTC and hwmon subsystems). Daniel, Thomas, do you have any objections to merging watchdog support via this driver, or would you have me split that off into a separate driver. I could potentially do that using a shared regmap, but it seems a bit of a stretch for something this simple. Thierry
On Fri, Mar 20, 2020 at 06:23:35PM +0300, Dmitry Osipenko wrote: > 20.03.2020 18:04, Thierry Reding пишет: > > On Fri, Mar 20, 2020 at 05:39:01PM +0300, Dmitry Osipenko wrote: > >> 20.03.2020 16:34, Thierry Reding пишет: > >>> From: Thierry Reding <treding@nvidia.com> > >>> > >>> Currently this only supports a single watchdog, which uses a timer in > >>> the background for countdown. Eventually the timers could be used for > >>> various time-keeping tasks, but by default the architected timer will > >>> already provide that functionality. > >>> > >>> Signed-off-by: Thierry Reding <treding@nvidia.com> > >>> --- > >>> drivers/clocksource/Kconfig | 8 + > >>> drivers/clocksource/Makefile | 1 + > >>> drivers/clocksource/timer-tegra186.c | 377 +++++++++++++++++++++++++++ > >>> 3 files changed, 386 insertions(+) > >>> create mode 100644 drivers/clocksource/timer-tegra186.c > >> Hello Thierry, > >> > >> Shouldn't this driver reside in drivers/watchdog/? Like it's done in a > >> case of the T30+ driver. > > > > The hardware block that this binds to is primarily a time-keeping block > > that just so happens to also implement a watchdog. Moving this to > > drivers/watchdog would put us into an odd situation if we ever added > > code to also implement the time-keeping bits for this hardware. > > > > I also think that the way this is done on Tegra30 was a bad choice. The > > problem is that we now have two drivers (tegra_wdt.c and tegra-timer.c) > > that both access the same region of memory. This seems to be relatively > > safe to do on those chips because there's no overlap between the timer > > and the watchdog interfaces, but on Tegra186 and later the watchdog is > > actually using one of the timers, so we'd have to be extra careful how > > to coordinate between the two. It seems much easier to do that by having > > everything in the same driver and have that register multiple devices in > > the system. > > Sounds like a watchdog on Tegra20, where one of the timer is shared with > a watchdog function and there are no other free timers. Well, yes, it's > not nice. > > But, will you really ever need an additional clocksource on T186? Actually there are a couple of interesting clocksources that this IP block exposes. It contains both a microsecond clock that might come in useful because it is used as a reference by some other blocks that work with microsecond counters (some hardware sequencers have this). Another one is the OSC, which is the system's main oscillator that most clocks are derived from. Perhaps the most useful source from a software point of view is the TSC. It's a timestamp counter that can also be used as a reference for HW timestamping of certain system events, which is something that we want to upstream eventually. Having the TSC exposed as a clocksource can be interesting because it allows us to correlate these hardware timestamps with code path execution. I've implemented the three clocksources above for v2, which makes this a bit more of an actual clocksource driver that additionally provides a watchdog. Thierry
diff --git a/drivers/clocksource/Kconfig b/drivers/clocksource/Kconfig index f2142e6bbea3..54d1b27d1f8b 100644 --- a/drivers/clocksource/Kconfig +++ b/drivers/clocksource/Kconfig @@ -149,6 +149,14 @@ config TEGRA_TIMER help Enables support for the Tegra driver. +config TEGRA186_TIMER + bool "NVIDIA Tegra186 timer driver" + depends on ARCH_TEGRA || COMPILE_TEST + select TIMER_OF + help + Enables support for the timers and watchdogs found on NVIDIA + Tegra186 and later SoCs. + config VT8500_TIMER bool "VT8500 timer driver" if COMPILE_TEST depends on HAS_IOMEM diff --git a/drivers/clocksource/Makefile b/drivers/clocksource/Makefile index 641ba5383ab5..ffa7950f4b7c 100644 --- a/drivers/clocksource/Makefile +++ b/drivers/clocksource/Makefile @@ -38,6 +38,7 @@ obj-$(CONFIG_SUN4I_TIMER) += timer-sun4i.o obj-$(CONFIG_SUN5I_HSTIMER) += timer-sun5i.o obj-$(CONFIG_MESON6_TIMER) += timer-meson6.o obj-$(CONFIG_TEGRA_TIMER) += timer-tegra.o +obj-$(CONFIG_TEGRA186_TIMER) += timer-tegra186.o obj-$(CONFIG_VT8500_TIMER) += timer-vt8500.o obj-$(CONFIG_NSPIRE_TIMER) += timer-zevio.o obj-$(CONFIG_BCM_KONA_TIMER) += bcm_kona_timer.o diff --git a/drivers/clocksource/timer-tegra186.c b/drivers/clocksource/timer-tegra186.c new file mode 100644 index 000000000000..f8bdda041e3a --- /dev/null +++ b/drivers/clocksource/timer-tegra186.c @@ -0,0 +1,377 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * Copyright (c) 2019-2020 NVIDIA Corporation. All rights reserved. + */ + +#include <linux/module.h> +#include <linux/interrupt.h> +#include <linux/io.h> +#include <linux/of.h> +#include <linux/of_device.h> +#include <linux/platform_device.h> +#include <linux/pm.h> +#include <linux/watchdog.h> + +/* shared registers */ +#define TKEIE(x) (0x100 + ((x) * 4)) +#define TKEIE_WDT_MASK(x, y) ((y) << (16 + 4 * (x))) + +/* timer registers */ +#define TMRCR 0x000 +#define TMRCR_ENABLE BIT(31) +#define TMRCR_PERIODIC BIT(30) +#define TMRCR_PTV(x) ((x) & 0x0fffffff) + +#define TMRSR 0x004 +#define TMRSR_INTR_CLR BIT(30) + +#define TMRCSSR 0x008 +#define TMRCSSR_SRC_USEC (0 << 0) + +/* watchdog registers */ +#define WDTCR 0x000 +#define WDTCR_SYSTEM_POR_RESET_ENABLE BIT(16) +#define WDTCR_SYSTEM_DEBUG_RESET_ENABLE BIT(15) +#define WDTCR_REMOTE_INT_ENABLE BIT(14) +#define WDTCR_LOCAL_FIQ_ENABLE BIT(13) +#define WDTCR_LOCAL_INT_ENABLE BIT(12) +#define WDTCR_PERIOD_MASK (0xff << 4) +#define WDTCR_PERIOD(x) (((x) & 0xff) << 4) +#define WDTCR_TIMER_SOURCE_MASK 0xf +#define WDTCR_TIMER_SOURCE(x) ((x) & 0xf) + +#define WDTCMDR 0x008 +#define WDTCMDR_DISABLE_COUNTER BIT(1) +#define WDTCMDR_START_COUNTER BIT(0) + +#define WDTUR 0x00c +#define WDTUR_UNLOCK_PATTERN 0x0000c45a + +struct tegra186_timer_soc { + unsigned int num_timers; + unsigned int num_wdts; +}; + +struct tegra186_tmr { + struct tegra186_timer *parent; + void __iomem *regs; + unsigned int index; + unsigned int hwirq; +}; + +struct tegra186_wdt { + struct watchdog_device base; + + void __iomem *regs; + unsigned int index; + bool locked; + + struct tegra186_tmr *tmr; +}; + +static inline struct tegra186_wdt *to_tegra186_wdt(struct watchdog_device *wdd) +{ + return container_of(wdd, struct tegra186_wdt, base); +} + +struct tegra186_timer { + const struct tegra186_timer_soc *soc; + struct device *dev; + void __iomem *regs; + unsigned int irq; + + struct tegra186_wdt *wdt; +}; + +static void tmr_writel(struct tegra186_tmr *tmr, u32 value, unsigned int offset) +{ + writel(value, tmr->regs + offset); +} + +static void wdt_writel(struct tegra186_wdt *wdt, u32 value, unsigned int offset) +{ + writel(value, wdt->regs + offset); +} + +static u32 wdt_readl(struct tegra186_wdt *wdt, unsigned int offset) +{ + return readl(wdt->regs + offset); +} + +static struct tegra186_tmr *tegra186_tmr_create(struct tegra186_timer *tegra, + unsigned int index) +{ + unsigned int offset = 0x10000 + index * 0x10000; + struct tegra186_tmr *tmr; + + tmr = devm_kzalloc(tegra->dev, sizeof(*tmr), GFP_KERNEL); + if (!tmr) + return ERR_PTR(-ENOMEM); + + tmr->parent = tegra; + tmr->regs = tegra->regs + offset; + tmr->index = index; + tmr->hwirq = 0; + + return tmr; +} + +static const struct watchdog_info tegra186_wdt_info = { + .options = WDIOF_SETTIMEOUT | WDIOF_MAGICCLOSE | WDIOF_KEEPALIVEPING, + .identity = "NVIDIA Tegra186 WDT", +}; + +static void tegra186_wdt_disable(struct tegra186_wdt *wdt) +{ + /* unlock and disable the watchdog */ + wdt_writel(wdt, WDTUR_UNLOCK_PATTERN, WDTUR); + wdt_writel(wdt, WDTCMDR_DISABLE_COUNTER, WDTCMDR); + + /* disable timer */ + tmr_writel(wdt->tmr, 0, TMRCR); +} + +static void tegra186_wdt_enable(struct tegra186_wdt *wdt) +{ + struct tegra186_timer *tegra = wdt->tmr->parent; + u32 value; + + /* unmask hardware IRQ, this may have been lost across powergate */ + value = TKEIE_WDT_MASK(wdt->index, 1); + writel(value, tegra->regs + TKEIE(wdt->tmr->hwirq)); + + /* clear interrupt */ + tmr_writel(wdt->tmr, TMRSR_INTR_CLR, TMRSR); + + /* select microsecond source */ + tmr_writel(wdt->tmr, TMRCSSR_SRC_USEC, TMRCSSR); + + /* configure timer (system reset happens on the fifth expiration) */ + value = TMRCR_PTV(wdt->base.timeout * USEC_PER_SEC / 5) | + TMRCR_PERIODIC | TMRCR_ENABLE; + tmr_writel(wdt->tmr, value, TMRCR); + + if (!wdt->locked) { + value = wdt_readl(wdt, WDTCR); + + /* select the proper timer source */ + value &= ~WDTCR_TIMER_SOURCE_MASK; + value |= WDTCR_TIMER_SOURCE(wdt->tmr->index); + + /* single timer period since that's already configured */ + value &= ~WDTCR_PERIOD_MASK; + value |= WDTCR_PERIOD(1); + + /* enable local interrupt for WDT petting */ + value |= WDTCR_LOCAL_INT_ENABLE; + + /* enable local FIQ and remote interrupt for debug dump */ + if (0) + value |= WDTCR_REMOTE_INT_ENABLE | + WDTCR_LOCAL_FIQ_ENABLE; + + /* enable system debug reset (doesn't properly reboot) */ + if (0) + value |= WDTCR_SYSTEM_DEBUG_RESET_ENABLE; + + /* enable system POR reset */ + value |= WDTCR_SYSTEM_POR_RESET_ENABLE; + + wdt_writel(wdt, value, WDTCR); + } + + wdt_writel(wdt, WDTCMDR_START_COUNTER, WDTCMDR); +} + +static int tegra186_wdt_start(struct watchdog_device *wdd) +{ + struct tegra186_wdt *wdt = to_tegra186_wdt(wdd); + + tegra186_wdt_enable(wdt); + + return 0; +} + +static int tegra186_wdt_stop(struct watchdog_device *wdd) +{ + struct tegra186_wdt *wdt = to_tegra186_wdt(wdd); + + tegra186_wdt_disable(wdt); + + return 0; +} + +static int tegra186_wdt_ping(struct watchdog_device *wdd) +{ + struct tegra186_wdt *wdt = to_tegra186_wdt(wdd); + + tegra186_wdt_disable(wdt); + tegra186_wdt_enable(wdt); + + return 0; +} + +static int tegra186_wdt_set_timeout(struct watchdog_device *wdd, + unsigned int timeout) +{ + struct tegra186_wdt *wdt = to_tegra186_wdt(wdd); + + tegra186_wdt_disable(wdt); + wdt->base.timeout = timeout; + tegra186_wdt_enable(wdt); + + return 0; +} + +static const struct watchdog_ops tegra186_wdt_ops = { + .owner = THIS_MODULE, + .start = tegra186_wdt_start, + .stop = tegra186_wdt_stop, + .ping = tegra186_wdt_ping, + .set_timeout = tegra186_wdt_set_timeout, +}; + +static struct tegra186_wdt *tegra186_wdt_create(struct tegra186_timer *tegra, + unsigned int index) +{ + unsigned int offset = 0x10000, source; + struct tegra186_wdt *wdt; + u32 value; + int err; + + offset += tegra->soc->num_timers * 0x10000 + index * 0x10000; + + wdt = devm_kzalloc(tegra->dev, sizeof(*wdt), GFP_KERNEL); + if (!wdt) + return ERR_PTR(-ENOMEM); + + wdt->regs = tegra->regs + offset; + wdt->index = index; + + /* read the watchdog configuration since it might be locked down */ + value = wdt_readl(wdt, WDTCR); + + if (value & WDTCR_LOCAL_INT_ENABLE) + wdt->locked = true; + + source = value & WDTCR_TIMER_SOURCE_MASK; + + wdt->tmr = tegra186_tmr_create(tegra, source); + if (IS_ERR(wdt->tmr)) + return ERR_CAST(wdt->tmr); + + wdt->base.info = &tegra186_wdt_info; + wdt->base.ops = &tegra186_wdt_ops; + wdt->base.min_timeout = 1; + wdt->base.max_timeout = 255; + wdt->base.parent = tegra->dev; + + err = watchdog_init_timeout(&wdt->base, 5, tegra->dev); + if (err < 0) { + dev_err(tegra->dev, "failed to initialize timeout: %d\n", err); + return ERR_PTR(err); + } + + err = devm_watchdog_register_device(tegra->dev, &wdt->base); + if (err < 0) { + dev_err(tegra->dev, "failed to register WDT: %d\n", err); + return ERR_PTR(err); + } + + return wdt; +} + +static irqreturn_t tegra186_timer_irq(int irq, void *data) +{ + struct tegra186_timer *tegra = data; + + if (tegra->wdt) { + tegra186_wdt_disable(tegra->wdt); + tegra186_wdt_enable(tegra->wdt); + } + + return IRQ_HANDLED; +} + +static int tegra186_timer_probe(struct platform_device *pdev) +{ + struct tegra186_timer *tegra; + int err; + + tegra = devm_kzalloc(&pdev->dev, sizeof(*tegra), GFP_KERNEL); + if (!tegra) + return -ENOMEM; + + tegra->soc = of_device_get_match_data(&pdev->dev); + dev_set_drvdata(&pdev->dev, tegra); + tegra->dev = &pdev->dev; + + tegra->regs = devm_platform_ioremap_resource(pdev, 0); + if (IS_ERR(tegra->regs)) + return PTR_ERR(tegra->regs); + + err = platform_get_irq(pdev, 0); + if (err < 0) { + dev_err(tegra->dev, "failed to get interrupt #0: %d\n", err); + return err; + } + + tegra->irq = err; + + err = devm_request_irq(tegra->dev, tegra->irq, tegra186_timer_irq, + IRQF_ONESHOT | IRQF_TRIGGER_HIGH, + "tegra186-timer", tegra); + if (err < 0) { + dev_err(tegra->dev, "failed to request IRQ#%u: %d\n", + tegra->irq, err); + return err; + } + + /* create a watchdog using a preconfigured timer */ + tegra->wdt = tegra186_wdt_create(tegra, 0); + if (IS_ERR(tegra->wdt)) { + err = PTR_ERR(tegra->wdt); + dev_err(&pdev->dev, "failed to create WDT: %d\n", err); + return err; + } + + return 0; +} + +static int __maybe_unused tegra186_timer_suspend(struct device *dev) +{ + return 0; +} + +static int __maybe_unused tegra186_timer_resume(struct device *dev) +{ + return 0; +} + +static SIMPLE_DEV_PM_OPS(tegra186_timer_pm_ops, tegra186_timer_suspend, + tegra186_timer_resume); + +static const struct tegra186_timer_soc tegra186_timer = { + .num_timers = 10, + .num_wdts = 3, +}; + +static const struct of_device_id tegra186_timer_of_match[] = { + { .compatible = "nvidia,tegra186-timer", .data = &tegra186_timer }, + { } +}; + +static struct platform_driver tegra186_wdt_driver = { + .driver = { + .name = "tegra186-timer", + .pm = &tegra186_timer_pm_ops, + .of_match_table = tegra186_timer_of_match, + .suppress_bind_attrs = true, + }, + .probe = tegra186_timer_probe, +}; +module_platform_driver(tegra186_wdt_driver); + +MODULE_AUTHOR("Thierry Reding <treding@nvidia.com>"); +MODULE_DESCRIPTION("NVIDIA Tegra186 timers driver"); +MODULE_LICENSE("GPL v2");