forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
336 lines
8.4 KiB
336 lines
8.4 KiB
// SPDX-License-Identifier: GPL-2.0-only |
|
/* |
|
* Copyright (C) Maxime Coquelin 2015 |
|
* Author: Maxime Coquelin <[email protected]> |
|
* |
|
* Inspired by time-efm32.c from Uwe Kleine-Koenig |
|
*/ |
|
|
|
#include <linux/kernel.h> |
|
#include <linux/clocksource.h> |
|
#include <linux/clockchips.h> |
|
#include <linux/delay.h> |
|
#include <linux/irq.h> |
|
#include <linux/interrupt.h> |
|
#include <linux/of.h> |
|
#include <linux/of_address.h> |
|
#include <linux/of_irq.h> |
|
#include <linux/clk.h> |
|
#include <linux/reset.h> |
|
#include <linux/sched_clock.h> |
|
#include <linux/slab.h> |
|
|
|
#include "timer-of.h" |
|
|
|
#define TIM_CR1 0x00 |
|
#define TIM_DIER 0x0c |
|
#define TIM_SR 0x10 |
|
#define TIM_EGR 0x14 |
|
#define TIM_CNT 0x24 |
|
#define TIM_PSC 0x28 |
|
#define TIM_ARR 0x2c |
|
#define TIM_CCR1 0x34 |
|
|
|
#define TIM_CR1_CEN BIT(0) |
|
#define TIM_CR1_UDIS BIT(1) |
|
#define TIM_CR1_OPM BIT(3) |
|
#define TIM_CR1_ARPE BIT(7) |
|
|
|
#define TIM_DIER_UIE BIT(0) |
|
#define TIM_DIER_CC1IE BIT(1) |
|
|
|
#define TIM_SR_UIF BIT(0) |
|
|
|
#define TIM_EGR_UG BIT(0) |
|
|
|
#define TIM_PSC_MAX USHRT_MAX |
|
#define TIM_PSC_CLKRATE 10000 |
|
|
|
struct stm32_timer_private { |
|
int bits; |
|
}; |
|
|
|
/** |
|
* stm32_timer_of_bits_set - set accessor helper |
|
* @to: a timer_of structure pointer |
|
* @bits: the number of bits (16 or 32) |
|
* |
|
* Accessor helper to set the number of bits in the timer-of private |
|
* structure. |
|
* |
|
*/ |
|
static void stm32_timer_of_bits_set(struct timer_of *to, int bits) |
|
{ |
|
struct stm32_timer_private *pd = to->private_data; |
|
|
|
pd->bits = bits; |
|
} |
|
|
|
/** |
|
* stm32_timer_of_bits_get - get accessor helper |
|
* @to: a timer_of structure pointer |
|
* |
|
* Accessor helper to get the number of bits in the timer-of private |
|
* structure. |
|
* |
|
* Returns an integer corresponding to the number of bits. |
|
*/ |
|
static int stm32_timer_of_bits_get(struct timer_of *to) |
|
{ |
|
struct stm32_timer_private *pd = to->private_data; |
|
|
|
return pd->bits; |
|
} |
|
|
|
static void __iomem *stm32_timer_cnt __read_mostly; |
|
|
|
static u64 notrace stm32_read_sched_clock(void) |
|
{ |
|
return readl_relaxed(stm32_timer_cnt); |
|
} |
|
|
|
static struct delay_timer stm32_timer_delay; |
|
|
|
static unsigned long stm32_read_delay(void) |
|
{ |
|
return readl_relaxed(stm32_timer_cnt); |
|
} |
|
|
|
static void stm32_clock_event_disable(struct timer_of *to) |
|
{ |
|
writel_relaxed(0, timer_of_base(to) + TIM_DIER); |
|
} |
|
|
|
/** |
|
* stm32_timer_start - Start the counter without event |
|
* @to: a timer_of structure pointer |
|
* |
|
* Start the timer in order to have the counter reset and start |
|
* incrementing but disable interrupt event when there is a counter |
|
* overflow. By default, the counter direction is used as upcounter. |
|
*/ |
|
static void stm32_timer_start(struct timer_of *to) |
|
{ |
|
writel_relaxed(TIM_CR1_UDIS | TIM_CR1_CEN, timer_of_base(to) + TIM_CR1); |
|
} |
|
|
|
static int stm32_clock_event_shutdown(struct clock_event_device *clkevt) |
|
{ |
|
struct timer_of *to = to_timer_of(clkevt); |
|
|
|
stm32_clock_event_disable(to); |
|
|
|
return 0; |
|
} |
|
|
|
static int stm32_clock_event_set_next_event(unsigned long evt, |
|
struct clock_event_device *clkevt) |
|
{ |
|
struct timer_of *to = to_timer_of(clkevt); |
|
unsigned long now, next; |
|
|
|
next = readl_relaxed(timer_of_base(to) + TIM_CNT) + evt; |
|
writel_relaxed(next, timer_of_base(to) + TIM_CCR1); |
|
now = readl_relaxed(timer_of_base(to) + TIM_CNT); |
|
|
|
if ((next - now) > evt) |
|
return -ETIME; |
|
|
|
writel_relaxed(TIM_DIER_CC1IE, timer_of_base(to) + TIM_DIER); |
|
|
|
return 0; |
|
} |
|
|
|
static int stm32_clock_event_set_periodic(struct clock_event_device *clkevt) |
|
{ |
|
struct timer_of *to = to_timer_of(clkevt); |
|
|
|
stm32_timer_start(to); |
|
|
|
return stm32_clock_event_set_next_event(timer_of_period(to), clkevt); |
|
} |
|
|
|
static int stm32_clock_event_set_oneshot(struct clock_event_device *clkevt) |
|
{ |
|
struct timer_of *to = to_timer_of(clkevt); |
|
|
|
stm32_timer_start(to); |
|
|
|
return 0; |
|
} |
|
|
|
static irqreturn_t stm32_clock_event_handler(int irq, void *dev_id) |
|
{ |
|
struct clock_event_device *clkevt = (struct clock_event_device *)dev_id; |
|
struct timer_of *to = to_timer_of(clkevt); |
|
|
|
writel_relaxed(0, timer_of_base(to) + TIM_SR); |
|
|
|
if (clockevent_state_periodic(clkevt)) |
|
stm32_clock_event_set_periodic(clkevt); |
|
else |
|
stm32_clock_event_shutdown(clkevt); |
|
|
|
clkevt->event_handler(clkevt); |
|
|
|
return IRQ_HANDLED; |
|
} |
|
|
|
/** |
|
* stm32_timer_width - Sort out the timer width (32/16) |
|
* @to: a pointer to a timer-of structure |
|
* |
|
* Write the 32-bit max value and read/return the result. If the timer |
|
* is 32 bits wide, the result will be UINT_MAX, otherwise it will |
|
* be truncated by the 16-bit register to USHRT_MAX. |
|
* |
|
*/ |
|
static void __init stm32_timer_set_width(struct timer_of *to) |
|
{ |
|
u32 width; |
|
|
|
writel_relaxed(UINT_MAX, timer_of_base(to) + TIM_ARR); |
|
|
|
width = readl_relaxed(timer_of_base(to) + TIM_ARR); |
|
|
|
stm32_timer_of_bits_set(to, width == UINT_MAX ? 32 : 16); |
|
} |
|
|
|
/** |
|
* stm32_timer_set_prescaler - Compute and set the prescaler register |
|
* @to: a pointer to a timer-of structure |
|
* |
|
* Depending on the timer width, compute the prescaler to always |
|
* target a 10MHz timer rate for 16 bits. 32-bit timers are |
|
* considered precise and long enough to not use the prescaler. |
|
*/ |
|
static void __init stm32_timer_set_prescaler(struct timer_of *to) |
|
{ |
|
int prescaler = 1; |
|
|
|
if (stm32_timer_of_bits_get(to) != 32) { |
|
prescaler = DIV_ROUND_CLOSEST(timer_of_rate(to), |
|
TIM_PSC_CLKRATE); |
|
/* |
|
* The prescaler register is an u16, the variable |
|
* can't be greater than TIM_PSC_MAX, let's cap it in |
|
* this case. |
|
*/ |
|
prescaler = prescaler < TIM_PSC_MAX ? prescaler : TIM_PSC_MAX; |
|
} |
|
|
|
writel_relaxed(prescaler - 1, timer_of_base(to) + TIM_PSC); |
|
writel_relaxed(TIM_EGR_UG, timer_of_base(to) + TIM_EGR); |
|
writel_relaxed(0, timer_of_base(to) + TIM_SR); |
|
|
|
/* Adjust rate and period given the prescaler value */ |
|
to->of_clk.rate = DIV_ROUND_CLOSEST(to->of_clk.rate, prescaler); |
|
to->of_clk.period = DIV_ROUND_UP(to->of_clk.rate, HZ); |
|
} |
|
|
|
static int __init stm32_clocksource_init(struct timer_of *to) |
|
{ |
|
u32 bits = stm32_timer_of_bits_get(to); |
|
const char *name = to->np->full_name; |
|
|
|
/* |
|
* This driver allows to register several timers and relies on |
|
* the generic time framework to select the right one. |
|
* However, nothing allows to do the same for the |
|
* sched_clock. We are not interested in a sched_clock for the |
|
* 16-bit timers but only for the 32-bit one, so if no 32-bit |
|
* timer is registered yet, we select this 32-bit timer as a |
|
* sched_clock. |
|
*/ |
|
if (bits == 32 && !stm32_timer_cnt) { |
|
|
|
/* |
|
* Start immediately the counter as we will be using |
|
* it right after. |
|
*/ |
|
stm32_timer_start(to); |
|
|
|
stm32_timer_cnt = timer_of_base(to) + TIM_CNT; |
|
sched_clock_register(stm32_read_sched_clock, bits, timer_of_rate(to)); |
|
pr_info("%s: STM32 sched_clock registered\n", name); |
|
|
|
stm32_timer_delay.read_current_timer = stm32_read_delay; |
|
stm32_timer_delay.freq = timer_of_rate(to); |
|
register_current_timer_delay(&stm32_timer_delay); |
|
pr_info("%s: STM32 delay timer registered\n", name); |
|
} |
|
|
|
return clocksource_mmio_init(timer_of_base(to) + TIM_CNT, name, |
|
timer_of_rate(to), bits == 32 ? 250 : 100, |
|
bits, clocksource_mmio_readl_up); |
|
} |
|
|
|
static void __init stm32_clockevent_init(struct timer_of *to) |
|
{ |
|
u32 bits = stm32_timer_of_bits_get(to); |
|
|
|
to->clkevt.name = to->np->full_name; |
|
to->clkevt.features = CLOCK_EVT_FEAT_PERIODIC | CLOCK_EVT_FEAT_ONESHOT; |
|
to->clkevt.set_state_shutdown = stm32_clock_event_shutdown; |
|
to->clkevt.set_state_periodic = stm32_clock_event_set_periodic; |
|
to->clkevt.set_state_oneshot = stm32_clock_event_set_oneshot; |
|
to->clkevt.tick_resume = stm32_clock_event_shutdown; |
|
to->clkevt.set_next_event = stm32_clock_event_set_next_event; |
|
to->clkevt.rating = bits == 32 ? 250 : 100; |
|
|
|
clockevents_config_and_register(&to->clkevt, timer_of_rate(to), 0x1, |
|
(1 << bits) - 1); |
|
|
|
pr_info("%pOF: STM32 clockevent driver initialized (%d bits)\n", |
|
to->np, bits); |
|
} |
|
|
|
static int __init stm32_timer_init(struct device_node *node) |
|
{ |
|
struct reset_control *rstc; |
|
struct timer_of *to; |
|
int ret; |
|
|
|
to = kzalloc(sizeof(*to), GFP_KERNEL); |
|
if (!to) |
|
return -ENOMEM; |
|
|
|
to->flags = TIMER_OF_IRQ | TIMER_OF_CLOCK | TIMER_OF_BASE; |
|
to->of_irq.handler = stm32_clock_event_handler; |
|
|
|
ret = timer_of_init(node, to); |
|
if (ret) |
|
goto err; |
|
|
|
to->private_data = kzalloc(sizeof(struct stm32_timer_private), |
|
GFP_KERNEL); |
|
if (!to->private_data) { |
|
ret = -ENOMEM; |
|
goto deinit; |
|
} |
|
|
|
rstc = of_reset_control_get(node, NULL); |
|
if (!IS_ERR(rstc)) { |
|
reset_control_assert(rstc); |
|
reset_control_deassert(rstc); |
|
} |
|
|
|
stm32_timer_set_width(to); |
|
|
|
stm32_timer_set_prescaler(to); |
|
|
|
ret = stm32_clocksource_init(to); |
|
if (ret) |
|
goto deinit; |
|
|
|
stm32_clockevent_init(to); |
|
return 0; |
|
|
|
deinit: |
|
timer_of_cleanup(to); |
|
err: |
|
kfree(to); |
|
return ret; |
|
} |
|
|
|
TIMER_OF_DECLARE(stm32, "st,stm32-timer", stm32_timer_init);
|
|
|