Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * arch/arm/mach-pxa/time.c | |
3 | * | |
7bbb18c9 BG |
4 | * PXA clocksource, clockevents, and OST interrupt handlers. |
5 | * Copyright (c) 2007 by Bill Gatliff <bgat@billgatliff.com>. | |
6 | * | |
7 | * Derived from Nicolas Pitre's PXA timer handler Copyright (c) 2001 | |
8 | * by MontaVista Software, Inc. (Nico, your code rocks!) | |
1da177e4 LT |
9 | * |
10 | * This program is free software; you can redistribute it and/or modify | |
11 | * it under the terms of the GNU General Public License version 2 as | |
12 | * published by the Free Software Foundation. | |
13 | */ | |
14 | ||
1da177e4 LT |
15 | #include <linux/kernel.h> |
16 | #include <linux/init.h> | |
1da177e4 | 17 | #include <linux/interrupt.h> |
ab5354c4 | 18 | #include <linux/clk.h> |
7bbb18c9 | 19 | #include <linux/clockchips.h> |
ab5354c4 RJ |
20 | #include <linux/of_address.h> |
21 | #include <linux/of_irq.h> | |
38ff87f7 | 22 | #include <linux/sched_clock.h> |
7bbb18c9 | 23 | |
6c3a1583 | 24 | #include <asm/div64.h> |
ab5354c4 RJ |
25 | |
26 | #define OSMR0 0x00 /* OS Timer 0 Match Register */ | |
27 | #define OSMR1 0x04 /* OS Timer 1 Match Register */ | |
28 | #define OSMR2 0x08 /* OS Timer 2 Match Register */ | |
29 | #define OSMR3 0x0C /* OS Timer 3 Match Register */ | |
30 | ||
31 | #define OSCR 0x10 /* OS Timer Counter Register */ | |
32 | #define OSSR 0x14 /* OS Timer Status Register */ | |
33 | #define OWER 0x18 /* OS Timer Watchdog Enable Register */ | |
34 | #define OIER 0x1C /* OS Timer Interrupt Enable Register */ | |
35 | ||
36 | #define OSSR_M3 (1 << 3) /* Match status channel 3 */ | |
37 | #define OSSR_M2 (1 << 2) /* Match status channel 2 */ | |
38 | #define OSSR_M1 (1 << 1) /* Match status channel 1 */ | |
39 | #define OSSR_M0 (1 << 0) /* Match status channel 0 */ | |
40 | ||
41 | #define OIER_E0 (1 << 0) /* Interrupt enable channel 0 */ | |
1da177e4 | 42 | |
6c3a1583 NP |
43 | /* |
44 | * This is PXA's sched_clock implementation. This has a resolution | |
45 | * of at least 308 ns and a maximum value of 208 days. | |
46 | * | |
47 | * The return value is guaranteed to be monotonic in that range as | |
48 | * long as there is always less than 582 seconds between successive | |
49 | * calls to sched_clock() which should always be the case in practice. | |
50 | */ | |
51 | ||
ab5354c4 RJ |
52 | #define timer_readl(reg) readl_relaxed(timer_base + (reg)) |
53 | #define timer_writel(val, reg) writel_relaxed((val), timer_base + (reg)) | |
54 | ||
55 | static void __iomem *timer_base; | |
56 | ||
364ed1e0 | 57 | static u64 notrace pxa_read_sched_clock(void) |
6c3a1583 | 58 | { |
ab5354c4 | 59 | return timer_readl(OSCR); |
6c3a1583 NP |
60 | } |
61 | ||
62 | ||
a88264c2 RK |
63 | #define MIN_OSCR_DELTA 16 |
64 | ||
1da177e4 | 65 | static irqreturn_t |
7bbb18c9 | 66 | pxa_ost0_interrupt(int irq, void *dev_id) |
1da177e4 | 67 | { |
7bbb18c9 BG |
68 | struct clock_event_device *c = dev_id; |
69 | ||
a88264c2 | 70 | /* Disarm the compare/match, signal the event. */ |
ab5354c4 RJ |
71 | timer_writel(timer_readl(OIER) & ~OIER_E0, OIER); |
72 | timer_writel(OSSR_M0, OSSR); | |
a88264c2 | 73 | c->event_handler(c); |
1da177e4 LT |
74 | |
75 | return IRQ_HANDLED; | |
76 | } | |
77 | ||
7bbb18c9 BG |
78 | static int |
79 | pxa_osmr0_set_next_event(unsigned long delta, struct clock_event_device *dev) | |
80 | { | |
a602f0f2 | 81 | unsigned long next, oscr; |
7bbb18c9 | 82 | |
ab5354c4 RJ |
83 | timer_writel(timer_readl(OIER) | OIER_E0, OIER); |
84 | next = timer_readl(OSCR) + delta; | |
85 | timer_writel(next, OSMR0); | |
86 | oscr = timer_readl(OSCR); | |
91bc51d8 RK |
87 | |
88 | return (signed)(next - oscr) <= MIN_OSCR_DELTA ? -ETIME : 0; | |
7bbb18c9 BG |
89 | } |
90 | ||
47d490ea | 91 | static int pxa_osmr0_shutdown(struct clock_event_device *evt) |
7bbb18c9 | 92 | { |
47d490ea VK |
93 | /* initializing, released, or preparing for suspend */ |
94 | timer_writel(timer_readl(OIER) & ~OIER_E0, OIER); | |
95 | timer_writel(OSSR_M0, OSSR); | |
96 | return 0; | |
7bbb18c9 BG |
97 | } |
98 | ||
5b30d5bf SW |
99 | #ifdef CONFIG_PM |
100 | static unsigned long osmr[4], oier, oscr; | |
101 | ||
102 | static void pxa_timer_suspend(struct clock_event_device *cedev) | |
103 | { | |
ab5354c4 RJ |
104 | osmr[0] = timer_readl(OSMR0); |
105 | osmr[1] = timer_readl(OSMR1); | |
106 | osmr[2] = timer_readl(OSMR2); | |
107 | osmr[3] = timer_readl(OSMR3); | |
108 | oier = timer_readl(OIER); | |
109 | oscr = timer_readl(OSCR); | |
5b30d5bf SW |
110 | } |
111 | ||
112 | static void pxa_timer_resume(struct clock_event_device *cedev) | |
113 | { | |
114 | /* | |
115 | * Ensure that we have at least MIN_OSCR_DELTA between match | |
116 | * register 0 and the OSCR, to guarantee that we will receive | |
117 | * the one-shot timer interrupt. We adjust OSMR0 in preference | |
118 | * to OSCR to guarantee that OSCR is monotonically incrementing. | |
119 | */ | |
120 | if (osmr[0] - oscr < MIN_OSCR_DELTA) | |
121 | osmr[0] += MIN_OSCR_DELTA; | |
122 | ||
ab5354c4 RJ |
123 | timer_writel(osmr[0], OSMR0); |
124 | timer_writel(osmr[1], OSMR1); | |
125 | timer_writel(osmr[2], OSMR2); | |
126 | timer_writel(osmr[3], OSMR3); | |
127 | timer_writel(oier, OIER); | |
128 | timer_writel(oscr, OSCR); | |
5b30d5bf SW |
129 | } |
130 | #else | |
131 | #define pxa_timer_suspend NULL | |
132 | #define pxa_timer_resume NULL | |
133 | #endif | |
134 | ||
7bbb18c9 | 135 | static struct clock_event_device ckevt_pxa_osmr0 = { |
47d490ea VK |
136 | .name = "osmr0", |
137 | .features = CLOCK_EVT_FEAT_ONESHOT, | |
138 | .rating = 200, | |
139 | .set_next_event = pxa_osmr0_set_next_event, | |
140 | .set_state_shutdown = pxa_osmr0_shutdown, | |
141 | .set_state_oneshot = pxa_osmr0_shutdown, | |
142 | .suspend = pxa_timer_suspend, | |
143 | .resume = pxa_timer_resume, | |
1da177e4 LT |
144 | }; |
145 | ||
7bbb18c9 BG |
146 | static struct irqaction pxa_ost0_irq = { |
147 | .name = "ost0", | |
ed7936f9 | 148 | .flags = IRQF_TIMER | IRQF_IRQPOLL, |
7bbb18c9 BG |
149 | .handler = pxa_ost0_interrupt, |
150 | .dev_id = &ckevt_pxa_osmr0, | |
151 | }; | |
152 | ||
6f2116eb | 153 | static void __init pxa_timer_common_init(int irq, unsigned long clock_tick_rate) |
1da177e4 | 154 | { |
ab5354c4 RJ |
155 | timer_writel(0, OIER); |
156 | timer_writel(OSSR_M0 | OSSR_M1 | OSSR_M2 | OSSR_M3, OSSR); | |
1da177e4 | 157 | |
364ed1e0 | 158 | sched_clock_register(pxa_read_sched_clock, 32, clock_tick_rate); |
6c3a1583 | 159 | |
320ab2b0 | 160 | ckevt_pxa_osmr0.cpumask = cpumask_of(0); |
1da177e4 | 161 | |
ab5354c4 | 162 | setup_irq(irq, &pxa_ost0_irq); |
5c53ff08 | 163 | |
ab5354c4 RJ |
164 | clocksource_mmio_init(timer_base + OSCR, "oscr0", clock_tick_rate, 200, |
165 | 32, clocksource_mmio_readl_up); | |
8d84981e | 166 | clockevents_config_and_register(&ckevt_pxa_osmr0, clock_tick_rate, |
ab5354c4 RJ |
167 | MIN_OSCR_DELTA * 2, 0x7fffffff); |
168 | } | |
169 | ||
170 | static void __init pxa_timer_dt_init(struct device_node *np) | |
171 | { | |
172 | struct clk *clk; | |
173 | int irq; | |
174 | ||
175 | /* timer registers are shared with watchdog timer */ | |
176 | timer_base = of_iomap(np, 0); | |
177 | if (!timer_base) | |
178 | panic("%s: unable to map resource\n", np->name); | |
179 | ||
180 | clk = of_clk_get(np, 0); | |
181 | if (IS_ERR(clk)) { | |
182 | pr_crit("%s: unable to get clk\n", np->name); | |
183 | return; | |
184 | } | |
185 | clk_prepare_enable(clk); | |
186 | ||
187 | /* we are only interested in OS-timer0 irq */ | |
188 | irq = irq_of_parse_and_map(np, 0); | |
189 | if (irq <= 0) { | |
190 | pr_crit("%s: unable to parse OS-timer0 irq\n", np->name); | |
191 | return; | |
192 | } | |
193 | ||
194 | pxa_timer_common_init(irq, clk_get_rate(clk)); | |
195 | } | |
196 | CLOCKSOURCE_OF_DECLARE(pxa_timer, "marvell,pxa-timer", pxa_timer_dt_init); | |
197 | ||
198 | /* | |
199 | * Legacy timer init for non device-tree boards. | |
200 | */ | |
201 | void __init pxa_timer_nodt_init(int irq, void __iomem *base, | |
202 | unsigned long clock_tick_rate) | |
203 | { | |
204 | struct clk *clk; | |
205 | ||
206 | timer_base = base; | |
207 | clk = clk_get(NULL, "OSTIMER0"); | |
208 | if (clk && !IS_ERR(clk)) | |
209 | clk_prepare_enable(clk); | |
210 | else | |
211 | pr_crit("%s: unable to get clk\n", __func__); | |
212 | ||
213 | pxa_timer_common_init(irq, clock_tick_rate); | |
5c53ff08 | 214 | } |