mirror of
https://mirrors.bfsu.edu.cn/git/linux.git
synced 2024-12-06 02:24:14 +08:00
1727339590
The CLOCKSOURCE_OF_DECLARE macro is used widely for the timers to declare the clocksource at early stage. However, this macro is also used to initialize the clockevent if any, or the clockevent only. It was originally suggested to declare another macro to initialize a clockevent, so in order to separate the two entities even they belong to the same IP. This was not accepted because of the impact on the DT where splitting a clocksource/clockevent definition does not make sense as it is a Linux concept not a hardware description. On the other side, the clocksource has not interrupt declared while the clockevent has, so it is easy from the driver to know if the description is for a clockevent or a clocksource, IOW it could be implemented at the driver level. So instead of dealing with a named clocksource macro, let's use a more generic one: TIMER_OF_DECLARE. The patch has not functional changes. Signed-off-by: Daniel Lezcano <daniel.lezcano@linaro.org> Acked-by: Heiko Stuebner <heiko@sntech.de> Acked-by: Neil Armstrong <narmstrong@baylibre.com> Acked-by: Arnd Bergmann <arnd@arndb.de> Acked-by: Matthias Brugger <matthias.bgg@gmail.com> Reviewed-by: Linus Walleij <linus.walleij@linaro.org>
417 lines
10 KiB
C
417 lines
10 KiB
C
/*
|
|
* Marvell Armada 370/XP SoC timer handling.
|
|
*
|
|
* Copyright (C) 2012 Marvell
|
|
*
|
|
* Lior Amsalem <alior@marvell.com>
|
|
* Gregory CLEMENT <gregory.clement@free-electrons.com>
|
|
* Thomas Petazzoni <thomas.petazzoni@free-electrons.com>
|
|
*
|
|
* This file is licensed under the terms of the GNU General Public
|
|
* License version 2. This program is licensed "as is" without any
|
|
* warranty of any kind, whether express or implied.
|
|
*
|
|
* Timer 0 is used as free-running clocksource, while timer 1 is
|
|
* used as clock_event_device.
|
|
*
|
|
* ---
|
|
* Clocksource driver for Armada 370 and Armada XP SoC.
|
|
* This driver implements one compatible string for each SoC, given
|
|
* each has its own characteristics:
|
|
*
|
|
* * Armada 370 has no 25 MHz fixed timer.
|
|
*
|
|
* * Armada XP cannot work properly without such 25 MHz fixed timer as
|
|
* doing otherwise leads to using a clocksource whose frequency varies
|
|
* when doing cpufreq frequency changes.
|
|
*
|
|
* See Documentation/devicetree/bindings/timer/marvell,armada-370-xp-timer.txt
|
|
*/
|
|
|
|
#include <linux/init.h>
|
|
#include <linux/platform_device.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/clk.h>
|
|
#include <linux/cpu.h>
|
|
#include <linux/timer.h>
|
|
#include <linux/clockchips.h>
|
|
#include <linux/interrupt.h>
|
|
#include <linux/of.h>
|
|
#include <linux/of_irq.h>
|
|
#include <linux/of_address.h>
|
|
#include <linux/irq.h>
|
|
#include <linux/module.h>
|
|
#include <linux/sched_clock.h>
|
|
#include <linux/percpu.h>
|
|
#include <linux/syscore_ops.h>
|
|
|
|
#include <asm/delay.h>
|
|
|
|
/*
|
|
* Timer block registers.
|
|
*/
|
|
#define TIMER_CTRL_OFF 0x0000
|
|
#define TIMER0_EN BIT(0)
|
|
#define TIMER0_RELOAD_EN BIT(1)
|
|
#define TIMER0_25MHZ BIT(11)
|
|
#define TIMER0_DIV(div) ((div) << 19)
|
|
#define TIMER1_EN BIT(2)
|
|
#define TIMER1_RELOAD_EN BIT(3)
|
|
#define TIMER1_25MHZ BIT(12)
|
|
#define TIMER1_DIV(div) ((div) << 22)
|
|
#define TIMER_EVENTS_STATUS 0x0004
|
|
#define TIMER0_CLR_MASK (~0x1)
|
|
#define TIMER1_CLR_MASK (~0x100)
|
|
#define TIMER0_RELOAD_OFF 0x0010
|
|
#define TIMER0_VAL_OFF 0x0014
|
|
#define TIMER1_RELOAD_OFF 0x0018
|
|
#define TIMER1_VAL_OFF 0x001c
|
|
|
|
#define LCL_TIMER_EVENTS_STATUS 0x0028
|
|
/* Global timers are connected to the coherency fabric clock, and the
|
|
below divider reduces their incrementing frequency. */
|
|
#define TIMER_DIVIDER_SHIFT 5
|
|
#define TIMER_DIVIDER (1 << TIMER_DIVIDER_SHIFT)
|
|
|
|
/*
|
|
* SoC-specific data.
|
|
*/
|
|
static void __iomem *timer_base, *local_base;
|
|
static unsigned int timer_clk;
|
|
static bool timer25Mhz = true;
|
|
static u32 enable_mask;
|
|
|
|
/*
|
|
* Number of timer ticks per jiffy.
|
|
*/
|
|
static u32 ticks_per_jiffy;
|
|
|
|
static struct clock_event_device __percpu *armada_370_xp_evt;
|
|
|
|
static void local_timer_ctrl_clrset(u32 clr, u32 set)
|
|
{
|
|
writel((readl(local_base + TIMER_CTRL_OFF) & ~clr) | set,
|
|
local_base + TIMER_CTRL_OFF);
|
|
}
|
|
|
|
static u64 notrace armada_370_xp_read_sched_clock(void)
|
|
{
|
|
return ~readl(timer_base + TIMER0_VAL_OFF);
|
|
}
|
|
|
|
/*
|
|
* Clockevent handling.
|
|
*/
|
|
static int
|
|
armada_370_xp_clkevt_next_event(unsigned long delta,
|
|
struct clock_event_device *dev)
|
|
{
|
|
/*
|
|
* Clear clockevent timer interrupt.
|
|
*/
|
|
writel(TIMER0_CLR_MASK, local_base + LCL_TIMER_EVENTS_STATUS);
|
|
|
|
/*
|
|
* Setup new clockevent timer value.
|
|
*/
|
|
writel(delta, local_base + TIMER0_VAL_OFF);
|
|
|
|
/*
|
|
* Enable the timer.
|
|
*/
|
|
local_timer_ctrl_clrset(TIMER0_RELOAD_EN, enable_mask);
|
|
return 0;
|
|
}
|
|
|
|
static int armada_370_xp_clkevt_shutdown(struct clock_event_device *evt)
|
|
{
|
|
/*
|
|
* Disable timer.
|
|
*/
|
|
local_timer_ctrl_clrset(TIMER0_EN, 0);
|
|
|
|
/*
|
|
* ACK pending timer interrupt.
|
|
*/
|
|
writel(TIMER0_CLR_MASK, local_base + LCL_TIMER_EVENTS_STATUS);
|
|
return 0;
|
|
}
|
|
|
|
static int armada_370_xp_clkevt_set_periodic(struct clock_event_device *evt)
|
|
{
|
|
/*
|
|
* Setup timer to fire at 1/HZ intervals.
|
|
*/
|
|
writel(ticks_per_jiffy - 1, local_base + TIMER0_RELOAD_OFF);
|
|
writel(ticks_per_jiffy - 1, local_base + TIMER0_VAL_OFF);
|
|
|
|
/*
|
|
* Enable timer.
|
|
*/
|
|
local_timer_ctrl_clrset(0, TIMER0_RELOAD_EN | enable_mask);
|
|
return 0;
|
|
}
|
|
|
|
static int armada_370_xp_clkevt_irq;
|
|
|
|
static irqreturn_t armada_370_xp_timer_interrupt(int irq, void *dev_id)
|
|
{
|
|
/*
|
|
* ACK timer interrupt and call event handler.
|
|
*/
|
|
struct clock_event_device *evt = dev_id;
|
|
|
|
writel(TIMER0_CLR_MASK, local_base + LCL_TIMER_EVENTS_STATUS);
|
|
evt->event_handler(evt);
|
|
|
|
return IRQ_HANDLED;
|
|
}
|
|
|
|
/*
|
|
* Setup the local clock events for a CPU.
|
|
*/
|
|
static int armada_370_xp_timer_starting_cpu(unsigned int cpu)
|
|
{
|
|
struct clock_event_device *evt = per_cpu_ptr(armada_370_xp_evt, cpu);
|
|
u32 clr = 0, set = 0;
|
|
|
|
if (timer25Mhz)
|
|
set = TIMER0_25MHZ;
|
|
else
|
|
clr = TIMER0_25MHZ;
|
|
local_timer_ctrl_clrset(clr, set);
|
|
|
|
evt->name = "armada_370_xp_per_cpu_tick",
|
|
evt->features = CLOCK_EVT_FEAT_ONESHOT |
|
|
CLOCK_EVT_FEAT_PERIODIC;
|
|
evt->shift = 32,
|
|
evt->rating = 300,
|
|
evt->set_next_event = armada_370_xp_clkevt_next_event,
|
|
evt->set_state_shutdown = armada_370_xp_clkevt_shutdown;
|
|
evt->set_state_periodic = armada_370_xp_clkevt_set_periodic;
|
|
evt->set_state_oneshot = armada_370_xp_clkevt_shutdown;
|
|
evt->tick_resume = armada_370_xp_clkevt_shutdown;
|
|
evt->irq = armada_370_xp_clkevt_irq;
|
|
evt->cpumask = cpumask_of(cpu);
|
|
|
|
clockevents_config_and_register(evt, timer_clk, 1, 0xfffffffe);
|
|
enable_percpu_irq(evt->irq, 0);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int armada_370_xp_timer_dying_cpu(unsigned int cpu)
|
|
{
|
|
struct clock_event_device *evt = per_cpu_ptr(armada_370_xp_evt, cpu);
|
|
|
|
evt->set_state_shutdown(evt);
|
|
disable_percpu_irq(evt->irq);
|
|
return 0;
|
|
}
|
|
|
|
static u32 timer0_ctrl_reg, timer0_local_ctrl_reg;
|
|
|
|
static int armada_370_xp_timer_suspend(void)
|
|
{
|
|
timer0_ctrl_reg = readl(timer_base + TIMER_CTRL_OFF);
|
|
timer0_local_ctrl_reg = readl(local_base + TIMER_CTRL_OFF);
|
|
return 0;
|
|
}
|
|
|
|
static void armada_370_xp_timer_resume(void)
|
|
{
|
|
writel(0xffffffff, timer_base + TIMER0_VAL_OFF);
|
|
writel(0xffffffff, timer_base + TIMER0_RELOAD_OFF);
|
|
writel(timer0_ctrl_reg, timer_base + TIMER_CTRL_OFF);
|
|
writel(timer0_local_ctrl_reg, local_base + TIMER_CTRL_OFF);
|
|
}
|
|
|
|
static struct syscore_ops armada_370_xp_timer_syscore_ops = {
|
|
.suspend = armada_370_xp_timer_suspend,
|
|
.resume = armada_370_xp_timer_resume,
|
|
};
|
|
|
|
static unsigned long armada_370_delay_timer_read(void)
|
|
{
|
|
return ~readl(timer_base + TIMER0_VAL_OFF);
|
|
}
|
|
|
|
static struct delay_timer armada_370_delay_timer = {
|
|
.read_current_timer = armada_370_delay_timer_read,
|
|
};
|
|
|
|
static int __init armada_370_xp_timer_common_init(struct device_node *np)
|
|
{
|
|
u32 clr = 0, set = 0;
|
|
int res;
|
|
|
|
timer_base = of_iomap(np, 0);
|
|
if (!timer_base) {
|
|
pr_err("Failed to iomap\n");
|
|
return -ENXIO;
|
|
}
|
|
|
|
local_base = of_iomap(np, 1);
|
|
if (!local_base) {
|
|
pr_err("Failed to iomap\n");
|
|
return -ENXIO;
|
|
}
|
|
|
|
if (timer25Mhz) {
|
|
set = TIMER0_25MHZ;
|
|
enable_mask = TIMER0_EN;
|
|
} else {
|
|
clr = TIMER0_25MHZ;
|
|
enable_mask = TIMER0_EN | TIMER0_DIV(TIMER_DIVIDER_SHIFT);
|
|
}
|
|
atomic_io_modify(timer_base + TIMER_CTRL_OFF, clr | set, set);
|
|
local_timer_ctrl_clrset(clr, set);
|
|
|
|
/*
|
|
* We use timer 0 as clocksource, and private(local) timer 0
|
|
* for clockevents
|
|
*/
|
|
armada_370_xp_clkevt_irq = irq_of_parse_and_map(np, 4);
|
|
|
|
ticks_per_jiffy = (timer_clk + HZ / 2) / HZ;
|
|
|
|
/*
|
|
* Setup free-running clocksource timer (interrupts
|
|
* disabled).
|
|
*/
|
|
writel(0xffffffff, timer_base + TIMER0_VAL_OFF);
|
|
writel(0xffffffff, timer_base + TIMER0_RELOAD_OFF);
|
|
|
|
atomic_io_modify(timer_base + TIMER_CTRL_OFF,
|
|
TIMER0_RELOAD_EN | enable_mask,
|
|
TIMER0_RELOAD_EN | enable_mask);
|
|
|
|
armada_370_delay_timer.freq = timer_clk;
|
|
register_current_timer_delay(&armada_370_delay_timer);
|
|
|
|
/*
|
|
* Set scale and timer for sched_clock.
|
|
*/
|
|
sched_clock_register(armada_370_xp_read_sched_clock, 32, timer_clk);
|
|
|
|
res = clocksource_mmio_init(timer_base + TIMER0_VAL_OFF,
|
|
"armada_370_xp_clocksource",
|
|
timer_clk, 300, 32, clocksource_mmio_readl_down);
|
|
if (res) {
|
|
pr_err("Failed to initialize clocksource mmio\n");
|
|
return res;
|
|
}
|
|
|
|
armada_370_xp_evt = alloc_percpu(struct clock_event_device);
|
|
if (!armada_370_xp_evt)
|
|
return -ENOMEM;
|
|
|
|
/*
|
|
* Setup clockevent timer (interrupt-driven).
|
|
*/
|
|
res = request_percpu_irq(armada_370_xp_clkevt_irq,
|
|
armada_370_xp_timer_interrupt,
|
|
"armada_370_xp_per_cpu_tick",
|
|
armada_370_xp_evt);
|
|
/* Immediately configure the timer on the boot CPU */
|
|
if (res) {
|
|
pr_err("Failed to request percpu irq\n");
|
|
return res;
|
|
}
|
|
|
|
res = cpuhp_setup_state(CPUHP_AP_ARMADA_TIMER_STARTING,
|
|
"clockevents/armada:starting",
|
|
armada_370_xp_timer_starting_cpu,
|
|
armada_370_xp_timer_dying_cpu);
|
|
if (res) {
|
|
pr_err("Failed to setup hotplug state and timer\n");
|
|
return res;
|
|
}
|
|
|
|
register_syscore_ops(&armada_370_xp_timer_syscore_ops);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int __init armada_xp_timer_init(struct device_node *np)
|
|
{
|
|
struct clk *clk = of_clk_get_by_name(np, "fixed");
|
|
int ret;
|
|
|
|
if (IS_ERR(clk)) {
|
|
pr_err("Failed to get clock\n");
|
|
return PTR_ERR(clk);
|
|
}
|
|
|
|
ret = clk_prepare_enable(clk);
|
|
if (ret)
|
|
return ret;
|
|
|
|
timer_clk = clk_get_rate(clk);
|
|
|
|
return armada_370_xp_timer_common_init(np);
|
|
}
|
|
TIMER_OF_DECLARE(armada_xp, "marvell,armada-xp-timer",
|
|
armada_xp_timer_init);
|
|
|
|
static int __init armada_375_timer_init(struct device_node *np)
|
|
{
|
|
struct clk *clk;
|
|
int ret;
|
|
|
|
clk = of_clk_get_by_name(np, "fixed");
|
|
if (!IS_ERR(clk)) {
|
|
ret = clk_prepare_enable(clk);
|
|
if (ret)
|
|
return ret;
|
|
timer_clk = clk_get_rate(clk);
|
|
} else {
|
|
|
|
/*
|
|
* This fallback is required in order to retain proper
|
|
* devicetree backwards compatibility.
|
|
*/
|
|
clk = of_clk_get(np, 0);
|
|
|
|
/* Must have at least a clock */
|
|
if (IS_ERR(clk)) {
|
|
pr_err("Failed to get clock\n");
|
|
return PTR_ERR(clk);
|
|
}
|
|
|
|
ret = clk_prepare_enable(clk);
|
|
if (ret)
|
|
return ret;
|
|
|
|
timer_clk = clk_get_rate(clk) / TIMER_DIVIDER;
|
|
timer25Mhz = false;
|
|
}
|
|
|
|
return armada_370_xp_timer_common_init(np);
|
|
}
|
|
TIMER_OF_DECLARE(armada_375, "marvell,armada-375-timer",
|
|
armada_375_timer_init);
|
|
|
|
static int __init armada_370_timer_init(struct device_node *np)
|
|
{
|
|
struct clk *clk;
|
|
int ret;
|
|
|
|
clk = of_clk_get(np, 0);
|
|
if (IS_ERR(clk)) {
|
|
pr_err("Failed to get clock\n");
|
|
return PTR_ERR(clk);
|
|
}
|
|
|
|
ret = clk_prepare_enable(clk);
|
|
if (ret)
|
|
return ret;
|
|
|
|
timer_clk = clk_get_rate(clk) / TIMER_DIVIDER;
|
|
timer25Mhz = false;
|
|
|
|
return armada_370_xp_timer_common_init(np);
|
|
}
|
|
TIMER_OF_DECLARE(armada_370, "marvell,armada-370-timer",
|
|
armada_370_timer_init);
|