1 // SPDX-License-Identifier: GPL-2.0+
3 #include <linux/clocksource.h>
4 #include <linux/clockchips.h>
5 #include <linux/cpuhotplug.h>
6 #include <linux/interrupt.h>
8 #include <linux/iopoll.h>
11 #include <linux/of_address.h>
12 #include <linux/of_irq.h>
13 #include <linux/sched_clock.h>
15 #include <linux/clk/clk-conf.h>
17 #include <clocksource/timer-ti-dm.h>
18 #include <dt-bindings/bus/ti-sysc.h>
20 /* For type1, set SYSC_OMAP2_CLOCKACTIVITY for fck off on idle, l4 clock on */
21 #define DMTIMER_TYPE1_ENABLE ((1 << 9) | (SYSC_IDLE_SMART << 3) | \
22 SYSC_OMAP2_ENAWAKEUP | SYSC_OMAP2_AUTOIDLE)
23 #define DMTIMER_TYPE1_DISABLE (SYSC_OMAP2_SOFTRESET | SYSC_OMAP2_AUTOIDLE)
24 #define DMTIMER_TYPE2_ENABLE (SYSC_IDLE_SMART_WKUP << 2)
25 #define DMTIMER_RESET_WAIT 100000
27 #define DMTIMER_INST_DONT_CARE ~0U
29 static int counter_32k;
30 static u32 clocksource;
31 static u32 clockevent;
34 * Subset of the timer registers we use. Note that the register offsets
35 * depend on the timer revision detected.
37 struct dmtimer_systimer {
53 struct dmtimer_clockevent {
54 struct clock_event_device dev;
55 struct dmtimer_systimer t;
59 struct dmtimer_clocksource {
60 struct clocksource dev;
61 struct dmtimer_systimer t;
65 /* Assumes v1 ip if bits [31:16] are zero */
66 static bool dmtimer_systimer_revision1(struct dmtimer_systimer *t)
68 u32 tidr = readl_relaxed(t->base);
73 static void dmtimer_systimer_enable(struct dmtimer_systimer *t)
77 if (dmtimer_systimer_revision1(t))
78 val = DMTIMER_TYPE1_ENABLE;
80 val = DMTIMER_TYPE2_ENABLE;
82 writel_relaxed(val, t->base + t->sysc);
85 static void dmtimer_systimer_disable(struct dmtimer_systimer *t)
87 if (!dmtimer_systimer_revision1(t))
90 writel_relaxed(DMTIMER_TYPE1_DISABLE, t->base + t->sysc);
93 static int __init dmtimer_systimer_type1_reset(struct dmtimer_systimer *t)
95 void __iomem *syss = t->base + OMAP_TIMER_V1_SYS_STAT_OFFSET;
99 dmtimer_systimer_enable(t);
100 writel_relaxed(BIT(1) | BIT(2), t->base + t->ifctrl);
101 ret = readl_poll_timeout_atomic(syss, l, l & BIT(0), 100,
107 /* Note we must use io_base instead of func_base for type2 OCP regs */
108 static int __init dmtimer_systimer_type2_reset(struct dmtimer_systimer *t)
110 void __iomem *sysc = t->base + t->sysc;
113 dmtimer_systimer_enable(t);
114 l = readl_relaxed(sysc);
116 writel_relaxed(l, sysc);
118 return readl_poll_timeout_atomic(sysc, l, !(l & BIT(0)), 100,
122 static int __init dmtimer_systimer_reset(struct dmtimer_systimer *t)
126 if (dmtimer_systimer_revision1(t))
127 ret = dmtimer_systimer_type1_reset(t);
129 ret = dmtimer_systimer_type2_reset(t);
131 pr_err("%s failed with %i\n", __func__, ret);
139 static const struct of_device_id counter_match_table[] = {
140 { .compatible = "ti,omap-counter32k" },
145 * Check if the SoC als has a usable working 32 KiHz counter. The 32 KiHz
146 * counter is handled by timer-ti-32k, but we need to detect it as it
147 * affects the preferred dmtimer system timer configuration. There is
148 * typically no use for a dmtimer clocksource if the 32 KiHz counter is
149 * present, except on am437x as described below.
151 static void __init dmtimer_systimer_check_counter32k(void)
153 struct device_node *np;
158 np = of_find_matching_node(NULL, counter_match_table);
160 counter_32k = -ENODEV;
165 if (of_device_is_available(np))
168 counter_32k = -ENODEV;
173 static const struct of_device_id dmtimer_match_table[] = {
174 { .compatible = "ti,omap2420-timer", },
175 { .compatible = "ti,omap3430-timer", },
176 { .compatible = "ti,omap4430-timer", },
177 { .compatible = "ti,omap5430-timer", },
178 { .compatible = "ti,am335x-timer", },
179 { .compatible = "ti,am335x-timer-1ms", },
180 { .compatible = "ti,dm814-timer", },
181 { .compatible = "ti,dm816-timer", },
186 * Checks that system timers are configured to not reset and idle during
187 * the generic timer-ti-dm device driver probe. And that the system timer
188 * source clocks are properly configured. Also, let's not hog any DSP and
189 * PWM capable timers unnecessarily as system timers.
191 static bool __init dmtimer_is_preferred(struct device_node *np)
193 if (!of_device_is_available(np))
196 if (!of_property_read_bool(np->parent,
197 "ti,no-reset-on-init"))
200 if (!of_property_read_bool(np->parent, "ti,no-idle"))
203 /* Secure gptimer12 is always clocked with a fixed source */
204 if (!of_property_read_bool(np, "ti,timer-secure")) {
205 if (!of_property_read_bool(np, "assigned-clocks"))
208 if (!of_property_read_bool(np, "assigned-clock-parents"))
212 if (of_property_read_bool(np, "ti,timer-dsp"))
215 if (of_property_read_bool(np, "ti,timer-pwm"))
222 * Finds the first available usable always-on timer, and assigns it to either
223 * clockevent or clocksource depending if the counter_32k is available on the
226 * Some omap3 boards with unreliable oscillator must not use the counter_32k
227 * or dmtimer1 with 32 KiHz source. Additionally, the boards with unreliable
228 * oscillator should really set counter_32k as disabled, and delete dmtimer1
229 * ti,always-on property, but let's not count on it. For these quirky cases,
230 * we prefer using the always-on secure dmtimer12 with the internal 32 KiHz
231 * clock as the clocksource, and any available dmtimer as clockevent.
233 * For am437x, we are using am335x style dmtimer clocksource. It is unclear
234 * if this quirk handling is really needed, but let's change it separately
235 * based on testing as it might cause side effects.
237 static void __init dmtimer_systimer_assign_alwon(void)
239 struct device_node *np;
241 bool quirk_unreliable_oscillator = false;
243 /* Quirk unreliable 32 KiHz oscillator with incomplete dts */
244 if (of_machine_is_compatible("ti,omap3-beagle") ||
245 of_machine_is_compatible("timll,omap3-devkit8000")) {
246 quirk_unreliable_oscillator = true;
247 counter_32k = -ENODEV;
250 /* Quirk am437x using am335x style dmtimer clocksource */
251 if (of_machine_is_compatible("ti,am43"))
252 counter_32k = -ENODEV;
254 for_each_matching_node(np, dmtimer_match_table) {
255 if (!dmtimer_is_preferred(np))
258 if (of_property_read_bool(np, "ti,timer-alwon")) {
261 addr = of_get_address(np, 0, NULL, NULL);
262 pa = of_translate_address(np, addr);
264 /* Quirky omap3 boards must use dmtimer12 */
265 if (quirk_unreliable_oscillator &&
275 /* Usually no need for dmtimer clocksource if we have counter32 */
276 if (counter_32k >= 0) {
281 clockevent = DMTIMER_INST_DONT_CARE;
285 /* Finds the first usable dmtimer, used for the don't care case */
286 static u32 __init dmtimer_systimer_find_first_available(void)
288 struct device_node *np;
292 for_each_matching_node(np, dmtimer_match_table) {
293 if (!dmtimer_is_preferred(np))
296 addr = of_get_address(np, 0, NULL, NULL);
297 pa = of_translate_address(np, addr);
299 if (pa == clocksource || pa == clockevent) {
312 /* Selects the best clocksource and clockevent to use */
313 static void __init dmtimer_systimer_select_best(void)
315 dmtimer_systimer_check_counter32k();
316 dmtimer_systimer_assign_alwon();
318 if (clockevent == DMTIMER_INST_DONT_CARE)
319 clockevent = dmtimer_systimer_find_first_available();
321 pr_debug("%s: counter_32k: %i clocksource: %08x clockevent: %08x\n",
322 __func__, counter_32k, clocksource, clockevent);
325 /* Interface clocks are only available on some SoCs variants */
326 static int __init dmtimer_systimer_init_clock(struct dmtimer_systimer *t,
327 struct device_node *np,
336 is_ick = !strncmp(name, "ick", 3);
338 clock = of_clk_get_by_name(np, name);
339 if ((PTR_ERR(clock) == -EINVAL) && is_ick)
341 else if (IS_ERR(clock))
342 return PTR_ERR(clock);
344 error = clk_prepare_enable(clock);
348 r = clk_get_rate(clock);
362 static int __init dmtimer_systimer_setup(struct device_node *np,
363 struct dmtimer_systimer *t)
369 if (!of_device_is_compatible(np->parent, "ti,sysc"))
372 t->base = of_iomap(np, 0);
377 * Enable optional assigned-clock-parents configured at the timer
378 * node level. For regular device drivers, this is done automatically
379 * by bus related code such as platform_drv_probe().
381 error = of_clk_set_defaults(np, false);
383 pr_err("%s: clock source init failed: %i\n", __func__, error);
385 /* For ti-sysc, we have timer clocks at the parent module level */
386 error = dmtimer_systimer_init_clock(t, np->parent, "fck", &rate);
392 error = dmtimer_systimer_init_clock(t, np->parent, "ick", &rate);
396 if (dmtimer_systimer_revision1(t)) {
397 t->irq_stat = OMAP_TIMER_V1_STAT_OFFSET;
398 t->irq_ena = OMAP_TIMER_V1_INT_EN_OFFSET;
399 t->pend = _OMAP_TIMER_WRITE_PEND_OFFSET;
402 t->irq_stat = OMAP_TIMER_V2_IRQSTATUS;
403 t->irq_ena = OMAP_TIMER_V2_IRQENABLE_SET;
404 regbase = OMAP_TIMER_V2_FUNC_OFFSET;
405 t->pend = regbase + _OMAP_TIMER_WRITE_PEND_OFFSET;
408 t->sysc = OMAP_TIMER_OCP_CFG_OFFSET;
409 t->load = regbase + _OMAP_TIMER_LOAD_OFFSET;
410 t->counter = regbase + _OMAP_TIMER_COUNTER_OFFSET;
411 t->ctrl = regbase + _OMAP_TIMER_CTRL_OFFSET;
412 t->wakeup = regbase + _OMAP_TIMER_WAKEUP_EN_OFFSET;
413 t->ifctrl = regbase + _OMAP_TIMER_IF_CTRL_OFFSET;
415 dmtimer_systimer_reset(t);
416 dmtimer_systimer_enable(t);
417 pr_debug("dmtimer rev %08x sysc %08x\n", readl_relaxed(t->base),
418 readl_relaxed(t->base + t->sysc));
429 static struct dmtimer_clockevent *
430 to_dmtimer_clockevent(struct clock_event_device *clockevent)
432 return container_of(clockevent, struct dmtimer_clockevent, dev);
435 static irqreturn_t dmtimer_clockevent_interrupt(int irq, void *data)
437 struct dmtimer_clockevent *clkevt = data;
438 struct dmtimer_systimer *t = &clkevt->t;
440 writel_relaxed(OMAP_TIMER_INT_OVERFLOW, t->base + t->irq_stat);
441 clkevt->dev.event_handler(&clkevt->dev);
446 static int dmtimer_set_next_event(unsigned long cycles,
447 struct clock_event_device *evt)
449 struct dmtimer_clockevent *clkevt = to_dmtimer_clockevent(evt);
450 struct dmtimer_systimer *t = &clkevt->t;
451 void __iomem *pend = t->base + t->pend;
453 while (readl_relaxed(pend) & WP_TCRR)
455 writel_relaxed(0xffffffff - cycles, t->base + t->counter);
457 while (readl_relaxed(pend) & WP_TCLR)
459 writel_relaxed(OMAP_TIMER_CTRL_ST, t->base + t->ctrl);
464 static int dmtimer_clockevent_shutdown(struct clock_event_device *evt)
466 struct dmtimer_clockevent *clkevt = to_dmtimer_clockevent(evt);
467 struct dmtimer_systimer *t = &clkevt->t;
468 void __iomem *ctrl = t->base + t->ctrl;
471 l = readl_relaxed(ctrl);
472 if (l & OMAP_TIMER_CTRL_ST) {
474 writel_relaxed(l, ctrl);
475 /* Flush posted write */
476 l = readl_relaxed(ctrl);
477 /* Wait for functional clock period x 3.5 */
478 udelay(3500000 / t->rate + 1);
480 writel_relaxed(OMAP_TIMER_INT_OVERFLOW, t->base + t->irq_stat);
485 static int dmtimer_set_periodic(struct clock_event_device *evt)
487 struct dmtimer_clockevent *clkevt = to_dmtimer_clockevent(evt);
488 struct dmtimer_systimer *t = &clkevt->t;
489 void __iomem *pend = t->base + t->pend;
491 dmtimer_clockevent_shutdown(evt);
493 /* Looks like we need to first set the load value separately */
494 while (readl_relaxed(pend) & WP_TLDR)
496 writel_relaxed(clkevt->period, t->base + t->load);
498 while (readl_relaxed(pend) & WP_TCRR)
500 writel_relaxed(clkevt->period, t->base + t->counter);
502 while (readl_relaxed(pend) & WP_TCLR)
504 writel_relaxed(OMAP_TIMER_CTRL_AR | OMAP_TIMER_CTRL_ST,
510 static void omap_clockevent_idle(struct clock_event_device *evt)
512 struct dmtimer_clockevent *clkevt = to_dmtimer_clockevent(evt);
513 struct dmtimer_systimer *t = &clkevt->t;
515 dmtimer_systimer_disable(t);
519 static void omap_clockevent_unidle(struct clock_event_device *evt)
521 struct dmtimer_clockevent *clkevt = to_dmtimer_clockevent(evt);
522 struct dmtimer_systimer *t = &clkevt->t;
525 error = clk_enable(t->fck);
527 pr_err("could not enable timer fck on resume: %i\n", error);
529 dmtimer_systimer_enable(t);
530 writel_relaxed(OMAP_TIMER_INT_OVERFLOW, t->base + t->irq_ena);
531 writel_relaxed(OMAP_TIMER_INT_OVERFLOW, t->base + t->wakeup);
534 static int __init dmtimer_clkevt_init_common(struct dmtimer_clockevent *clkevt,
535 struct device_node *np,
536 unsigned int features,
537 const struct cpumask *cpumask,
541 struct clock_event_device *dev;
542 struct dmtimer_systimer *t;
549 * We mostly use cpuidle_coupled with ARM local timers for runtime,
550 * so there's probably no use for CLOCK_EVT_FEAT_DYNIRQ here.
552 dev->features = features;
553 dev->rating = rating;
554 dev->set_next_event = dmtimer_set_next_event;
555 dev->set_state_shutdown = dmtimer_clockevent_shutdown;
556 dev->set_state_periodic = dmtimer_set_periodic;
557 dev->set_state_oneshot = dmtimer_clockevent_shutdown;
558 dev->set_state_oneshot_stopped = dmtimer_clockevent_shutdown;
559 dev->tick_resume = dmtimer_clockevent_shutdown;
560 dev->cpumask = cpumask;
562 dev->irq = irq_of_parse_and_map(np, 0);
566 error = dmtimer_systimer_setup(np, &clkevt->t);
570 clkevt->period = 0xffffffff - DIV_ROUND_CLOSEST(t->rate, HZ);
573 * For clock-event timers we never read the timer counter and
574 * so we are not impacted by errata i103 and i767. Therefore,
575 * we can safely ignore this errata for clock-event timers.
577 writel_relaxed(OMAP_TIMER_CTRL_POSTED, t->base + t->ifctrl);
579 error = request_irq(dev->irq, dmtimer_clockevent_interrupt,
580 IRQF_TIMER, name, clkevt);
584 writel_relaxed(OMAP_TIMER_INT_OVERFLOW, t->base + t->irq_ena);
585 writel_relaxed(OMAP_TIMER_INT_OVERFLOW, t->base + t->wakeup);
587 pr_info("TI gptimer %s: %s%lu Hz at %pOF\n",
588 name, of_find_property(np, "ti,timer-alwon", NULL) ?
589 "always-on " : "", t->rate, np->parent);
599 static int __init dmtimer_clockevent_init(struct device_node *np)
601 struct dmtimer_clockevent *clkevt;
604 clkevt = kzalloc(sizeof(*clkevt), GFP_KERNEL);
608 error = dmtimer_clkevt_init_common(clkevt, np,
609 CLOCK_EVT_FEAT_PERIODIC |
610 CLOCK_EVT_FEAT_ONESHOT,
611 cpu_possible_mask, "clockevent",
616 clockevents_config_and_register(&clkevt->dev, clkevt->t.rate,
617 3, /* Timer internal resync latency */
620 if (of_machine_is_compatible("ti,am33xx") ||
621 of_machine_is_compatible("ti,am43")) {
622 clkevt->dev.suspend = omap_clockevent_idle;
623 clkevt->dev.resume = omap_clockevent_unidle;
634 /* Dmtimer as percpu timer. See dra7 ARM architected timer wrap erratum i940 */
635 static DEFINE_PER_CPU(struct dmtimer_clockevent, dmtimer_percpu_timer);
637 static int __init dmtimer_percpu_timer_init(struct device_node *np, int cpu)
639 struct dmtimer_clockevent *clkevt;
642 if (!cpu_possible(cpu))
645 if (!of_property_read_bool(np->parent, "ti,no-reset-on-init") ||
646 !of_property_read_bool(np->parent, "ti,no-idle"))
647 pr_warn("Incomplete dtb for percpu dmtimer %pOF\n", np->parent);
649 clkevt = per_cpu_ptr(&dmtimer_percpu_timer, cpu);
651 error = dmtimer_clkevt_init_common(clkevt, np, CLOCK_EVT_FEAT_ONESHOT,
652 cpumask_of(cpu), "percpu-dmtimer",
660 /* See TRM for timer internal resynch latency */
661 static int omap_dmtimer_starting_cpu(unsigned int cpu)
663 struct dmtimer_clockevent *clkevt = per_cpu_ptr(&dmtimer_percpu_timer, cpu);
664 struct clock_event_device *dev = &clkevt->dev;
665 struct dmtimer_systimer *t = &clkevt->t;
667 clockevents_config_and_register(dev, t->rate, 3, ULONG_MAX);
668 irq_force_affinity(dev->irq, cpumask_of(cpu));
673 static int __init dmtimer_percpu_timer_startup(void)
675 struct dmtimer_clockevent *clkevt = per_cpu_ptr(&dmtimer_percpu_timer, 0);
676 struct dmtimer_systimer *t = &clkevt->t;
679 cpuhp_setup_state(CPUHP_AP_TI_GP_TIMER_STARTING,
680 "clockevents/omap/gptimer:starting",
681 omap_dmtimer_starting_cpu, NULL);
686 subsys_initcall(dmtimer_percpu_timer_startup);
688 static int __init dmtimer_percpu_quirk_init(struct device_node *np, u32 pa)
690 struct device_node *arm_timer;
692 arm_timer = of_find_compatible_node(NULL, NULL, "arm,armv7-timer");
693 if (of_device_is_available(arm_timer)) {
694 pr_warn_once("ARM architected timer wrap issue i940 detected\n");
698 if (pa == 0x48034000) /* dra7 dmtimer3 */
699 return dmtimer_percpu_timer_init(np, 0);
700 else if (pa == 0x48036000) /* dra7 dmtimer4 */
701 return dmtimer_percpu_timer_init(np, 1);
707 static struct dmtimer_clocksource *
708 to_dmtimer_clocksource(struct clocksource *cs)
710 return container_of(cs, struct dmtimer_clocksource, dev);
713 static u64 dmtimer_clocksource_read_cycles(struct clocksource *cs)
715 struct dmtimer_clocksource *clksrc = to_dmtimer_clocksource(cs);
716 struct dmtimer_systimer *t = &clksrc->t;
718 return (u64)readl_relaxed(t->base + t->counter);
721 static void __iomem *dmtimer_sched_clock_counter;
723 static u64 notrace dmtimer_read_sched_clock(void)
725 return readl_relaxed(dmtimer_sched_clock_counter);
728 static void dmtimer_clocksource_suspend(struct clocksource *cs)
730 struct dmtimer_clocksource *clksrc = to_dmtimer_clocksource(cs);
731 struct dmtimer_systimer *t = &clksrc->t;
733 clksrc->loadval = readl_relaxed(t->base + t->counter);
734 dmtimer_systimer_disable(t);
738 static void dmtimer_clocksource_resume(struct clocksource *cs)
740 struct dmtimer_clocksource *clksrc = to_dmtimer_clocksource(cs);
741 struct dmtimer_systimer *t = &clksrc->t;
744 error = clk_enable(t->fck);
746 pr_err("could not enable timer fck on resume: %i\n", error);
748 dmtimer_systimer_enable(t);
749 writel_relaxed(clksrc->loadval, t->base + t->counter);
750 writel_relaxed(OMAP_TIMER_CTRL_ST | OMAP_TIMER_CTRL_AR,
754 static int __init dmtimer_clocksource_init(struct device_node *np)
756 struct dmtimer_clocksource *clksrc;
757 struct dmtimer_systimer *t;
758 struct clocksource *dev;
761 clksrc = kzalloc(sizeof(*clksrc), GFP_KERNEL);
768 error = dmtimer_systimer_setup(np, t);
772 dev->name = "dmtimer";
774 dev->read = dmtimer_clocksource_read_cycles;
775 dev->mask = CLOCKSOURCE_MASK(32);
776 dev->flags = CLOCK_SOURCE_IS_CONTINUOUS;
778 /* Unlike for clockevent, legacy code sets suspend only for am4 */
779 if (of_machine_is_compatible("ti,am43")) {
780 dev->suspend = dmtimer_clocksource_suspend;
781 dev->resume = dmtimer_clocksource_resume;
784 writel_relaxed(0, t->base + t->counter);
785 writel_relaxed(OMAP_TIMER_CTRL_ST | OMAP_TIMER_CTRL_AR,
788 pr_info("TI gptimer clocksource: %s%pOF\n",
789 of_find_property(np, "ti,timer-alwon", NULL) ?
790 "always-on " : "", np->parent);
792 if (!dmtimer_sched_clock_counter) {
793 dmtimer_sched_clock_counter = t->base + t->counter;
794 sched_clock_register(dmtimer_read_sched_clock, 32, t->rate);
797 if (clocksource_register_hz(dev, t->rate))
798 pr_err("Could not register clocksource %pOF\n", np);
809 * To detect between a clocksource and clockevent, we assume the device tree
810 * has no interrupts configured for a clocksource timer.
812 static int __init dmtimer_systimer_init(struct device_node *np)
817 /* One time init for the preferred timer configuration */
818 if (!clocksource && !clockevent)
819 dmtimer_systimer_select_best();
821 if (!clocksource && !clockevent) {
822 pr_err("%s: unable to detect system timers, update dtb?\n",
828 addr = of_get_address(np, 0, NULL, NULL);
829 pa = of_translate_address(np, addr);
833 if (counter_32k <= 0 && clocksource == pa)
834 return dmtimer_clocksource_init(np);
836 if (clockevent == pa)
837 return dmtimer_clockevent_init(np);
839 if (of_machine_is_compatible("ti,dra7"))
840 return dmtimer_percpu_quirk_init(np, pa);
845 TIMER_OF_DECLARE(systimer_omap2, "ti,omap2420-timer", dmtimer_systimer_init);
846 TIMER_OF_DECLARE(systimer_omap3, "ti,omap3430-timer", dmtimer_systimer_init);
847 TIMER_OF_DECLARE(systimer_omap4, "ti,omap4430-timer", dmtimer_systimer_init);
848 TIMER_OF_DECLARE(systimer_omap5, "ti,omap5430-timer", dmtimer_systimer_init);
849 TIMER_OF_DECLARE(systimer_am33x, "ti,am335x-timer", dmtimer_systimer_init);
850 TIMER_OF_DECLARE(systimer_am3ms, "ti,am335x-timer-1ms", dmtimer_systimer_init);
851 TIMER_OF_DECLARE(systimer_dm814, "ti,dm814-timer", dmtimer_systimer_init);
852 TIMER_OF_DECLARE(systimer_dm816, "ti,dm816-timer", dmtimer_systimer_init);