108dbd0f8SThomas Gleixner // SPDX-License-Identifier: GPL-2.0-only
271e4a47fSRichard Kuo /*
371e4a47fSRichard Kuo * Time related functions for Hexagon architecture
471e4a47fSRichard Kuo *
5e1858b2aSRichard Kuo * Copyright (c) 2010-2011, The Linux Foundation. All rights reserved.
671e4a47fSRichard Kuo */
771e4a47fSRichard Kuo
871e4a47fSRichard Kuo #include <linux/init.h>
971e4a47fSRichard Kuo #include <linux/clockchips.h>
1071e4a47fSRichard Kuo #include <linux/clocksource.h>
1171e4a47fSRichard Kuo #include <linux/interrupt.h>
1271e4a47fSRichard Kuo #include <linux/err.h>
1371e4a47fSRichard Kuo #include <linux/platform_device.h>
1471e4a47fSRichard Kuo #include <linux/ioport.h>
1571e4a47fSRichard Kuo #include <linux/of.h>
1671e4a47fSRichard Kuo #include <linux/of_address.h>
1771e4a47fSRichard Kuo #include <linux/of_irq.h>
186bbbc30cSRichard Kuo #include <linux/module.h>
1971e4a47fSRichard Kuo
2071e4a47fSRichard Kuo #include <asm/hexagon_vm.h>
2171e4a47fSRichard Kuo
22*660859f0SNathan Chancellor #define TIMER_ENABLE BIT(0)
23*660859f0SNathan Chancellor
2471e4a47fSRichard Kuo /*
2571e4a47fSRichard Kuo * For the clocksource we need:
2671e4a47fSRichard Kuo * pcycle frequency (600MHz)
2771e4a47fSRichard Kuo * For the loops_per_jiffy we need:
2871e4a47fSRichard Kuo * thread/cpu frequency (100MHz)
2971e4a47fSRichard Kuo * And for the timer, we need:
3071e4a47fSRichard Kuo * sleep clock rate
3171e4a47fSRichard Kuo */
3271e4a47fSRichard Kuo
3371e4a47fSRichard Kuo cycles_t pcycle_freq_mhz;
3471e4a47fSRichard Kuo cycles_t thread_freq_mhz;
3571e4a47fSRichard Kuo cycles_t sleep_clk_freq;
3671e4a47fSRichard Kuo
37*660859f0SNathan Chancellor /*
38*660859f0SNathan Chancellor * 8x50 HDD Specs 5-8. Simulator co-sim not fixed until
39*660859f0SNathan Chancellor * release 1.1, and then it's "adjustable" and probably not defaulted.
40*660859f0SNathan Chancellor */
41*660859f0SNathan Chancellor #define RTOS_TIMER_INT 3
42*660859f0SNathan Chancellor #define RTOS_TIMER_REGS_ADDR 0xAB000000UL
43*660859f0SNathan Chancellor
4471e4a47fSRichard Kuo static struct resource rtos_timer_resources[] = {
4571e4a47fSRichard Kuo {
4671e4a47fSRichard Kuo .start = RTOS_TIMER_REGS_ADDR,
4771e4a47fSRichard Kuo .end = RTOS_TIMER_REGS_ADDR+PAGE_SIZE-1,
4871e4a47fSRichard Kuo .flags = IORESOURCE_MEM,
4971e4a47fSRichard Kuo },
5071e4a47fSRichard Kuo };
5171e4a47fSRichard Kuo
5271e4a47fSRichard Kuo static struct platform_device rtos_timer_device = {
5371e4a47fSRichard Kuo .name = "rtos_timer",
5471e4a47fSRichard Kuo .id = -1,
5571e4a47fSRichard Kuo .num_resources = ARRAY_SIZE(rtos_timer_resources),
5671e4a47fSRichard Kuo .resource = rtos_timer_resources,
5771e4a47fSRichard Kuo };
5871e4a47fSRichard Kuo
5971e4a47fSRichard Kuo /* A lot of this stuff should move into a platform specific section. */
6071e4a47fSRichard Kuo struct adsp_hw_timer_struct {
6171e4a47fSRichard Kuo u32 match; /* Match value */
6271e4a47fSRichard Kuo u32 count;
6371e4a47fSRichard Kuo u32 enable; /* [1] - CLR_ON_MATCH_EN, [0] - EN */
6471e4a47fSRichard Kuo u32 clear; /* one-shot register that clears the count */
6571e4a47fSRichard Kuo };
6671e4a47fSRichard Kuo
6771e4a47fSRichard Kuo /* Look for "TCX0" for related constants. */
6871e4a47fSRichard Kuo static __iomem struct adsp_hw_timer_struct *rtos_timer;
6971e4a47fSRichard Kuo
timer_get_cycles(struct clocksource * cs)70a5a1d1c2SThomas Gleixner static u64 timer_get_cycles(struct clocksource *cs)
7171e4a47fSRichard Kuo {
72a5a1d1c2SThomas Gleixner return (u64) __vmgettime();
7371e4a47fSRichard Kuo }
7471e4a47fSRichard Kuo
7571e4a47fSRichard Kuo static struct clocksource hexagon_clocksource = {
7671e4a47fSRichard Kuo .name = "pcycles",
7771e4a47fSRichard Kuo .rating = 250,
7871e4a47fSRichard Kuo .read = timer_get_cycles,
7971e4a47fSRichard Kuo .mask = CLOCKSOURCE_MASK(64),
8071e4a47fSRichard Kuo .flags = CLOCK_SOURCE_IS_CONTINUOUS,
8171e4a47fSRichard Kuo };
8271e4a47fSRichard Kuo
set_next_event(unsigned long delta,struct clock_event_device * evt)8371e4a47fSRichard Kuo static int set_next_event(unsigned long delta, struct clock_event_device *evt)
8471e4a47fSRichard Kuo {
8571e4a47fSRichard Kuo /* Assuming the timer will be disabled when we enter here. */
8671e4a47fSRichard Kuo
8771e4a47fSRichard Kuo iowrite32(1, &rtos_timer->clear);
8871e4a47fSRichard Kuo iowrite32(0, &rtos_timer->clear);
8971e4a47fSRichard Kuo
9071e4a47fSRichard Kuo iowrite32(delta, &rtos_timer->match);
91*660859f0SNathan Chancellor iowrite32(TIMER_ENABLE, &rtos_timer->enable);
9271e4a47fSRichard Kuo return 0;
9371e4a47fSRichard Kuo }
9471e4a47fSRichard Kuo
9571e4a47fSRichard Kuo #ifdef CONFIG_SMP
9671e4a47fSRichard Kuo /* Broadcast mechanism */
broadcast(const struct cpumask * mask)9771e4a47fSRichard Kuo static void broadcast(const struct cpumask *mask)
9871e4a47fSRichard Kuo {
9971e4a47fSRichard Kuo send_ipi(mask, IPI_TIMER);
10071e4a47fSRichard Kuo }
10171e4a47fSRichard Kuo #endif
10271e4a47fSRichard Kuo
103d70e22d5SViresh Kumar /* XXX Implement set_state_shutdown() */
10471e4a47fSRichard Kuo static struct clock_event_device hexagon_clockevent_dev = {
10571e4a47fSRichard Kuo .name = "clockevent",
10671e4a47fSRichard Kuo .features = CLOCK_EVT_FEAT_ONESHOT,
10771e4a47fSRichard Kuo .rating = 400,
10871e4a47fSRichard Kuo .irq = RTOS_TIMER_INT,
10971e4a47fSRichard Kuo .set_next_event = set_next_event,
11071e4a47fSRichard Kuo #ifdef CONFIG_SMP
11171e4a47fSRichard Kuo .broadcast = broadcast,
11271e4a47fSRichard Kuo #endif
11371e4a47fSRichard Kuo };
11471e4a47fSRichard Kuo
11571e4a47fSRichard Kuo #ifdef CONFIG_SMP
11671e4a47fSRichard Kuo static DEFINE_PER_CPU(struct clock_event_device, clock_events);
11771e4a47fSRichard Kuo
setup_percpu_clockdev(void)11871e4a47fSRichard Kuo void setup_percpu_clockdev(void)
11971e4a47fSRichard Kuo {
12071e4a47fSRichard Kuo int cpu = smp_processor_id();
12171e4a47fSRichard Kuo struct clock_event_device *ce_dev = &hexagon_clockevent_dev;
12271e4a47fSRichard Kuo struct clock_event_device *dummy_clock_dev =
12371e4a47fSRichard Kuo &per_cpu(clock_events, cpu);
12471e4a47fSRichard Kuo
12571e4a47fSRichard Kuo memcpy(dummy_clock_dev, ce_dev, sizeof(*dummy_clock_dev));
12671e4a47fSRichard Kuo INIT_LIST_HEAD(&dummy_clock_dev->list);
12771e4a47fSRichard Kuo
12871e4a47fSRichard Kuo dummy_clock_dev->features = CLOCK_EVT_FEAT_DUMMY;
12971e4a47fSRichard Kuo dummy_clock_dev->cpumask = cpumask_of(cpu);
13071e4a47fSRichard Kuo
13171e4a47fSRichard Kuo clockevents_register_device(dummy_clock_dev);
13271e4a47fSRichard Kuo }
13371e4a47fSRichard Kuo
13471e4a47fSRichard Kuo /* Called from smp.c for each CPU's timer ipi call */
ipi_timer(void)13571e4a47fSRichard Kuo void ipi_timer(void)
13671e4a47fSRichard Kuo {
13771e4a47fSRichard Kuo int cpu = smp_processor_id();
13871e4a47fSRichard Kuo struct clock_event_device *ce_dev = &per_cpu(clock_events, cpu);
13971e4a47fSRichard Kuo
14071e4a47fSRichard Kuo ce_dev->event_handler(ce_dev);
14171e4a47fSRichard Kuo }
14271e4a47fSRichard Kuo #endif /* CONFIG_SMP */
14371e4a47fSRichard Kuo
timer_interrupt(int irq,void * devid)14471e4a47fSRichard Kuo static irqreturn_t timer_interrupt(int irq, void *devid)
14571e4a47fSRichard Kuo {
14671e4a47fSRichard Kuo struct clock_event_device *ce_dev = &hexagon_clockevent_dev;
14771e4a47fSRichard Kuo
14871e4a47fSRichard Kuo iowrite32(0, &rtos_timer->enable);
14971e4a47fSRichard Kuo ce_dev->event_handler(ce_dev);
15071e4a47fSRichard Kuo
15171e4a47fSRichard Kuo return IRQ_HANDLED;
15271e4a47fSRichard Kuo }
15371e4a47fSRichard Kuo
15471e4a47fSRichard Kuo /*
15571e4a47fSRichard Kuo * time_init_deferred - called by start_kernel to set up timer/clock source
15671e4a47fSRichard Kuo *
15771e4a47fSRichard Kuo * Install the IRQ handler for the clock, setup timers.
15871e4a47fSRichard Kuo * This is done late, as that way, we can use ioremap().
15971e4a47fSRichard Kuo *
16071e4a47fSRichard Kuo * This runs just before the delay loop is calibrated, and
16171e4a47fSRichard Kuo * is used for delay calibration.
16271e4a47fSRichard Kuo */
time_init_deferred(void)16371e4a47fSRichard Kuo void __init time_init_deferred(void)
16471e4a47fSRichard Kuo {
16571e4a47fSRichard Kuo struct resource *resource = NULL;
16671e4a47fSRichard Kuo struct clock_event_device *ce_dev = &hexagon_clockevent_dev;
16745b26ddeSafzal mohammed unsigned long flag = IRQF_TIMER | IRQF_TRIGGER_RISING;
16871e4a47fSRichard Kuo
16971e4a47fSRichard Kuo ce_dev->cpumask = cpu_all_mask;
17071e4a47fSRichard Kuo
17171e4a47fSRichard Kuo if (!resource)
17271e4a47fSRichard Kuo resource = rtos_timer_device.resource;
17371e4a47fSRichard Kuo
17471e4a47fSRichard Kuo /* ioremap here means this has to run later, after paging init */
1753c0f13bcSThomas Meyer rtos_timer = ioremap(resource->start, resource_size(resource));
17671e4a47fSRichard Kuo
17771e4a47fSRichard Kuo if (!rtos_timer) {
1783c0f13bcSThomas Meyer release_mem_region(resource->start, resource_size(resource));
17971e4a47fSRichard Kuo }
18071e4a47fSRichard Kuo clocksource_register_khz(&hexagon_clocksource, pcycle_freq_mhz * 1000);
18171e4a47fSRichard Kuo
18271e4a47fSRichard Kuo /* Note: the sim generic RTOS clock is apparently really 18750Hz */
18371e4a47fSRichard Kuo
18471e4a47fSRichard Kuo /*
18571e4a47fSRichard Kuo * Last arg is some guaranteed seconds for which the conversion will
18671e4a47fSRichard Kuo * work without overflow.
18771e4a47fSRichard Kuo */
18871e4a47fSRichard Kuo clockevents_calc_mult_shift(ce_dev, sleep_clk_freq, 4);
18971e4a47fSRichard Kuo
19071e4a47fSRichard Kuo ce_dev->max_delta_ns = clockevent_delta2ns(0x7fffffff, ce_dev);
191a60a9fb8SNicolai Stange ce_dev->max_delta_ticks = 0x7fffffff;
19271e4a47fSRichard Kuo ce_dev->min_delta_ns = clockevent_delta2ns(0xf, ce_dev);
193a60a9fb8SNicolai Stange ce_dev->min_delta_ticks = 0xf;
19471e4a47fSRichard Kuo
19571e4a47fSRichard Kuo #ifdef CONFIG_SMP
19671e4a47fSRichard Kuo setup_percpu_clockdev();
19771e4a47fSRichard Kuo #endif
19871e4a47fSRichard Kuo
19971e4a47fSRichard Kuo clockevents_register_device(ce_dev);
20045b26ddeSafzal mohammed if (request_irq(ce_dev->irq, timer_interrupt, flag, "rtos_timer", NULL))
20145b26ddeSafzal mohammed pr_err("Failed to register rtos_timer interrupt\n");
20271e4a47fSRichard Kuo }
20371e4a47fSRichard Kuo
time_init(void)20471e4a47fSRichard Kuo void __init time_init(void)
20571e4a47fSRichard Kuo {
20671e4a47fSRichard Kuo late_time_init = time_init_deferred;
20771e4a47fSRichard Kuo }
20871e4a47fSRichard Kuo
__delay(unsigned long cycles)209196b933dSChen Gang void __delay(unsigned long cycles)
210196b933dSChen Gang {
211196b933dSChen Gang unsigned long long start = __vmgettime();
212196b933dSChen Gang
213196b933dSChen Gang while ((__vmgettime() - start) < cycles)
214196b933dSChen Gang cpu_relax();
215196b933dSChen Gang }
216196b933dSChen Gang EXPORT_SYMBOL(__delay);
217196b933dSChen Gang
21871e4a47fSRichard Kuo /*
21971e4a47fSRichard Kuo * This could become parametric or perhaps even computed at run-time,
22071e4a47fSRichard Kuo * but for now we take the observed simulator jitter.
22171e4a47fSRichard Kuo */
22271e4a47fSRichard Kuo static long long fudgefactor = 350; /* Maybe lower if kernel optimized. */
22371e4a47fSRichard Kuo
__udelay(unsigned long usecs)22471e4a47fSRichard Kuo void __udelay(unsigned long usecs)
22571e4a47fSRichard Kuo {
22671e4a47fSRichard Kuo unsigned long long start = __vmgettime();
22771e4a47fSRichard Kuo unsigned long long finish = (pcycle_freq_mhz * usecs) - fudgefactor;
22871e4a47fSRichard Kuo
22971e4a47fSRichard Kuo while ((__vmgettime() - start) < finish)
23071e4a47fSRichard Kuo cpu_relax(); /* not sure how this improves readability */
23171e4a47fSRichard Kuo }
23271e4a47fSRichard Kuo EXPORT_SYMBOL(__udelay);
233