| /* | |
| * Copyright 2017 NXP | |
| * | |
| * This program is free software; you can redistribute it and/or | |
| * modify it under the terms of the GNU General Public License | |
| * as published by the Free Software Foundation; either version 2 | |
| * of the License, or (at your option) any later version. | |
| */ | |
| #include <linux/interrupt.h> | |
| #include <linux/clockchips.h> | |
| #include <linux/clocksource.h> | |
| #include <linux/delay.h> | |
| #include <linux/of_address.h> | |
| #include <linux/of_irq.h> | |
| #include <linux/sched_clock.h> | |
| #define CNTCV_LO 0x8 | |
| #define CNTCV_HI 0xc | |
| #define CMPCV_LO 0x20 | |
| #define CMPCV_HI 0x24 | |
| #define CMPCR 0x2c | |
| #define SYS_CTR_EN 0x1 | |
| #define SYS_CTR_IRQ_MASK 0x2 | |
| static void __iomem *sys_ctr_rd_base; | |
| static void __iomem *sys_ctr_cmp_base; | |
| static struct clock_event_device clockevent_sysctr; | |
| static inline void sysctr_timer_enable(bool enable) | |
| { | |
| u32 val; | |
| val = readl(sys_ctr_cmp_base + CMPCR); | |
| val &= ~SYS_CTR_EN; | |
| if (enable) | |
| val |= SYS_CTR_EN; | |
| writel(val, sys_ctr_cmp_base + CMPCR); | |
| } | |
| static void sysctr_irq_acknowledge(void) | |
| { | |
| u32 val; | |
| /* clear th enable bit(EN=0) to clear the ISTAT */ | |
| val = readl(sys_ctr_cmp_base + CMPCR); | |
| val &= ~SYS_CTR_EN; | |
| writel(val, sys_ctr_cmp_base + CMPCR); | |
| } | |
| static inline u64 sysctr_read_counter(void) | |
| { | |
| u32 cnt_hi, tmp_hi, cnt_lo; | |
| do { | |
| cnt_hi = readl_relaxed(sys_ctr_rd_base + CNTCV_HI); | |
| cnt_lo = readl_relaxed(sys_ctr_rd_base + CNTCV_LO); | |
| tmp_hi = readl_relaxed(sys_ctr_rd_base + CNTCV_HI); | |
| } while (tmp_hi != cnt_hi); | |
| return ((u64) cnt_hi << 32) | cnt_lo; | |
| } | |
| static u64 notrace sysctr_read_sched_clock(void) | |
| { | |
| return sysctr_read_counter(); | |
| } | |
| static u64 sysctr_clocksourc_read(struct clocksource *cs) | |
| { | |
| return sysctr_read_counter(); | |
| } | |
| static int __init sysctr_clocksource_init(unsigned int rate) | |
| { | |
| sched_clock_register(sysctr_read_sched_clock, 56, rate); | |
| return clocksource_mmio_init(sys_ctr_rd_base, "imx sysctr", | |
| rate, 200, 56, sysctr_clocksourc_read); | |
| } | |
| static int sysctr_set_next_event(unsigned long delta, | |
| struct clock_event_device *evt) | |
| { | |
| u32 cmp_hi, cmp_lo; | |
| u64 next; | |
| sysctr_timer_enable(false); | |
| next = sysctr_read_counter(); | |
| next += delta; | |
| cmp_hi = (next >> 32) & 0x00fffff; | |
| cmp_lo = next & 0xffffffff; | |
| writel_relaxed(cmp_hi, sys_ctr_cmp_base + CMPCV_HI); | |
| writel_relaxed(cmp_lo, sys_ctr_cmp_base + CMPCV_LO); | |
| sysctr_timer_enable(true); | |
| return 0; | |
| } | |
| static int sysctr_set_state_oneshot(struct clock_event_device *evt) | |
| { | |
| /* enable timer */ | |
| sysctr_timer_enable(true); | |
| return 0; | |
| } | |
| static int sysctr_set_state_shutdown(struct clock_event_device *evt) | |
| { | |
| /* disable the timer */ | |
| sysctr_timer_enable(false); | |
| return 0; | |
| } | |
| static irqreturn_t sysctr_timer_interrupt(int irq, void *dev_id) | |
| { | |
| struct clock_event_device *evt = &clockevent_sysctr; | |
| sysctr_irq_acknowledge(); | |
| evt->event_handler(evt); | |
| return IRQ_HANDLED; | |
| } | |
| static struct clock_event_device clockevent_sysctr = { | |
| .name = "i.MX system counter timer", | |
| .features = CLOCK_EVT_FEAT_ONESHOT | CLOCK_EVT_FEAT_DYNIRQ, | |
| .set_state_oneshot = sysctr_set_state_oneshot, | |
| .set_next_event = sysctr_set_next_event, | |
| .set_state_shutdown = sysctr_set_state_shutdown, | |
| .rating = 200, | |
| }; | |
| static struct irqaction sysctr_timer_irq = { | |
| .name = "iMX system counter timer", | |
| .flags = IRQF_TIMER | IRQF_IRQPOLL, | |
| .handler = sysctr_timer_interrupt, | |
| .dev_id = &clockevent_sysctr, | |
| }; | |
| static int __init sysctr_clockevent_init(unsigned long rate, int irq) | |
| { | |
| setup_irq(irq, &sysctr_timer_irq); | |
| clockevent_sysctr.cpumask = cpumask_of(0); | |
| clockevent_sysctr.irq = irq; | |
| clockevents_config_and_register(&clockevent_sysctr, | |
| rate, 0xff, 0x7fffffff); | |
| return 0; | |
| } | |
| static int __init sysctr_timer_init(struct device_node *np) | |
| { | |
| u32 rate; | |
| int irq; | |
| pr_info("system counter timer init\n"); | |
| sys_ctr_rd_base = of_iomap(np, 0); | |
| BUG_ON(!sys_ctr_rd_base); | |
| sys_ctr_cmp_base = of_iomap(np, 1); | |
| BUG_ON(!sys_ctr_cmp_base); | |
| /* | |
| * the purpose of this driver is to provide a global timer, | |
| * So only use one compare frame, request frame0's irq only. | |
| */ | |
| irq = irq_of_parse_and_map(np, 0); | |
| if (of_property_read_u32(np, "clock-frequency", &rate)) | |
| return -EINVAL; | |
| sysctr_clocksource_init(rate); | |
| sysctr_clockevent_init(rate, irq); | |
| return 0; | |
| } | |
| CLOCKSOURCE_OF_DECLARE(imx8m, "nxp,sysctr-timer", sysctr_timer_init); |