ARM: tegra: clock: Make TWD optional
[linux-3.10.git] / arch / arm / mach-tegra / timer.c
1 /*
2  * arch/arch/mach-tegra/timer.c
3  *
4  * Copyright (C) 2010 Google, Inc.
5  *
6  * Author:
7  *      Colin Cross <ccross@google.com>
8  *
9  * Copyright (C) 2010-2012 NVIDIA Corporation.
10  *
11  * This software is licensed under the terms of the GNU General Public
12  * License version 2, as published by the Free Software Foundation, and
13  * may be copied, distributed, and modified under those terms.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU General Public License for more details.
19  *
20  */
21
22 #include <linux/init.h>
23 #include <linux/err.h>
24 #include <linux/time.h>
25 #include <linux/interrupt.h>
26 #include <linux/irq.h>
27 #include <linux/clockchips.h>
28 #include <linux/clocksource.h>
29 #include <linux/clk.h>
30 #include <linux/io.h>
31 #include <linux/syscore_ops.h>
32
33 #include <asm/mach/time.h>
34 #include <asm/delay.h>
35 #include <asm/smp_twd.h>
36 #include <asm/sched_clock.h>
37
38 #include <mach/irqs.h>
39
40 #include "board.h"
41 #include "clock.h"
42 #include "iomap.h"
43 #include "timer.h"
44
45 static void __iomem *timer_reg_base = IO_ADDRESS(TEGRA_TMR1_BASE);
46 static void __iomem *rtc_base = IO_ADDRESS(TEGRA_RTC_BASE);
47
48 static struct timespec persistent_ts;
49 static u64 persistent_ms, last_persistent_ms;
50 static u32 usec_config;
51 static u32 usec_offset;
52 static bool usec_suspended;
53
54 #ifdef CONFIG_ARCH_TEGRA_2x_SOC
55 static u32 system_timer = (TEGRA_TMR3_BASE - TEGRA_TMR1_BASE);
56 #else
57 static u32 system_timer = 0;
58 #endif
59
60 #define timer_writel(value, reg) \
61         __raw_writel(value, timer_reg_base + (reg))
62 #define timer_readl(reg) \
63         __raw_readl(timer_reg_base + (reg))
64
65 static int tegra_timer_set_next_event(unsigned long cycles,
66                                          struct clock_event_device *evt)
67 {
68         u32 reg;
69
70         reg = 0x80000000 | ((cycles > 1) ? (cycles-1) : 0);
71         timer_writel(reg, system_timer + TIMER_PTV);
72
73         return 0;
74 }
75
76 static void tegra_timer_set_mode(enum clock_event_mode mode,
77                                     struct clock_event_device *evt)
78 {
79         u32 reg;
80
81         timer_writel(0, system_timer + TIMER_PTV);
82
83         switch (mode) {
84         case CLOCK_EVT_MODE_PERIODIC:
85                 reg = 0xC0000000 | ((1000000/HZ)-1);
86                 timer_writel(reg, system_timer + TIMER_PTV);
87                 break;
88         case CLOCK_EVT_MODE_ONESHOT:
89                 break;
90         case CLOCK_EVT_MODE_UNUSED:
91         case CLOCK_EVT_MODE_SHUTDOWN:
92         case CLOCK_EVT_MODE_RESUME:
93                 break;
94         }
95 }
96
97 static struct clock_event_device tegra_clockevent = {
98         .name           = "timer0",
99         .rating         = 425,  /* Must be > dummy_timer and < local_timer */
100         .features       = CLOCK_EVT_FEAT_ONESHOT | CLOCK_EVT_FEAT_PERIODIC,
101         .set_next_event = tegra_timer_set_next_event,
102         .set_mode       = tegra_timer_set_mode,
103 };
104
105 static u32 notrace tegra_read_usec(void)
106 {
107         u32 cyc = usec_offset;
108         if (!usec_suspended)
109                 cyc += timer_readl(TIMERUS_CNTR_1US);
110         return cyc;
111 }
112
113 static u32 notrace tegra_read_sched_clock(void)
114 {
115         return tegra_read_usec();
116 }
117
118 /*
119  * tegra_rtc_read - Reads the Tegra RTC registers
120  * Care must be taken that this funciton is not called while the
121  * tegra_rtc driver could be executing to avoid race conditions
122  * on the RTC shadow register
123  */
124 static u64 tegra_rtc_read_ms(void)
125 {
126         u32 ms = readl(rtc_base + RTC_MILLISECONDS);
127         u32 s = readl(rtc_base + RTC_SHADOW_SECONDS);
128         return (u64)s * MSEC_PER_SEC + ms;
129 }
130
131 /*
132  * tegra_read_persistent_clock -  Return time from a persistent clock.
133  *
134  * Reads the time from a source which isn't disabled during PM, the
135  * 32k sync timer.  Convert the cycles elapsed since last read into
136  * nsecs and adds to a monotonically increasing timespec.
137  * Care must be taken that this funciton is not called while the
138  * tegra_rtc driver could be executing to avoid race conditions
139  * on the RTC shadow register
140  */
141 static void tegra_read_persistent_clock(struct timespec *ts)
142 {
143         u64 delta;
144         struct timespec *tsp = &persistent_ts;
145
146         last_persistent_ms = persistent_ms;
147         persistent_ms = tegra_rtc_read_ms();
148         delta = persistent_ms - last_persistent_ms;
149
150         timespec_add_ns(tsp, delta * NSEC_PER_MSEC);
151         *ts = *tsp;
152 }
153
154 static irqreturn_t tegra_timer_interrupt(int irq, void *dev_id)
155 {
156         struct clock_event_device *evt = (struct clock_event_device *)dev_id;
157         timer_writel(1<<30, system_timer + TIMER_PCR);
158         evt->event_handler(evt);
159         return IRQ_HANDLED;
160 }
161
162 static struct irqaction tegra_timer_irq = {
163         .name           = "timer0",
164         .flags          = IRQF_DISABLED | IRQF_TIMER | IRQF_TRIGGER_HIGH,
165         .handler        = tegra_timer_interrupt,
166         .dev_id         = &tegra_clockevent,
167 #ifdef CONFIG_ARCH_TEGRA_2x_SOC
168         .irq            = INT_TMR3,
169 #else
170         .irq            = INT_TMR1,
171 #endif
172 };
173
174 static int tegra_timer_suspend(void)
175 {
176         usec_config = timer_readl(TIMERUS_USEC_CFG);
177
178         usec_offset += timer_readl(TIMERUS_CNTR_1US);
179         usec_suspended = true;
180
181         return 0;
182 }
183
184 static void tegra_timer_resume(void)
185 {
186         timer_writel(usec_config, TIMERUS_USEC_CFG);
187
188         usec_offset -= timer_readl(TIMERUS_CNTR_1US);
189         usec_suspended = false;
190 }
191
192 static struct syscore_ops tegra_timer_syscore_ops = {
193         .suspend = tegra_timer_suspend,
194         .resume = tegra_timer_resume,
195 };
196
197 #ifdef CONFIG_HAVE_ARM_TWD
198 static DEFINE_TWD_LOCAL_TIMER(twd_local_timer,
199                               TEGRA_ARM_PERIF_BASE + 0x600,
200                               IRQ_LOCALTIMER);
201 static void __iomem *tegra_twd_base = IO_ADDRESS(TEGRA_ARM_PERIF_BASE + 0x600);
202
203 static void __init tegra_twd_init(void)
204 {
205         struct clk *cpu;
206         int ret;
207         int err;
208
209         /* The twd clock is a detached child of the CPU complex clock.
210            Force an update of the twd clock after DVFS has updated the
211            CPU clock rate. */
212
213         twd_clk = tegra_get_clock_by_name("twd");
214         BUG_ON(!twd_clk);
215         cpu = tegra_get_clock_by_name("cpu");
216         ret = clk_set_rate(twd_clk, clk_get_rate(cpu));
217
218         if (ret)
219                 pr_err("Failed to set twd clock rate: %d\n", ret);
220         else
221                 pr_debug("TWD clock rate: %ld\n", clk_get_rate(twd_clk));
222
223         err = twd_local_timer_register(&twd_local_timer);
224         if (err)
225                 pr_err("twd_local_timer_register failed %d\n", err);
226 }
227
228 int tegra_twd_get_state(struct tegra_twd_context *context)
229 {
230         context->twd_ctrl = readl(tegra_twd_base + TWD_TIMER_CONTROL);
231         context->twd_load = readl(tegra_twd_base + TWD_TIMER_LOAD);
232         context->twd_cnt = readl(tegra_twd_base + TWD_TIMER_COUNTER);
233
234         return 0;
235 }
236
237 void tegra_twd_suspend(struct tegra_twd_context *context)
238 {
239         context->twd_ctrl = readl(tegra_twd_base + TWD_TIMER_CONTROL);
240         context->twd_load = readl(tegra_twd_base + TWD_TIMER_LOAD);
241         if ((context->twd_load == 0) &&
242             (context->twd_ctrl & TWD_TIMER_CONTROL_PERIODIC) &&
243             (context->twd_ctrl & (TWD_TIMER_CONTROL_ENABLE |
244                                   TWD_TIMER_CONTROL_IT_ENABLE))) {
245                 WARN("%s: TWD enabled but counter was 0\n", __func__);
246                 context->twd_load = 1;
247         }
248         __raw_writel(0, tegra_twd_base + TWD_TIMER_CONTROL);
249 }
250
251 void tegra_twd_resume(struct tegra_twd_context *context)
252 {
253         BUG_ON((context->twd_load == 0) &&
254                (context->twd_ctrl & TWD_TIMER_CONTROL_PERIODIC) &&
255                (context->twd_ctrl & (TWD_TIMER_CONTROL_ENABLE |
256                                      TWD_TIMER_CONTROL_IT_ENABLE)));
257         writel(context->twd_load, tegra_twd_base + TWD_TIMER_LOAD);
258         writel(context->twd_ctrl, tegra_twd_base + TWD_TIMER_CONTROL);
259 }
260 #else
261 #define tegra_twd_init()        do {} while(0)
262 #define tegra_twd_get_state     do {} while(0)
263 #define tegra_twd_suspend       do {} while(0)
264 #define tegra_twd_resume        do {} while(0)
265 #endif
266
267 extern void __tegra_delay(unsigned long cycles);
268 extern void __tegra_const_udelay(unsigned long loops);
269 extern void __tegra_udelay(unsigned long usecs);
270
271 void __init tegra_init_timer(void)
272 {
273         struct clk *clk;
274         int ret;
275         unsigned long rate;
276
277         clk = clk_get_sys("timer", NULL);
278         if (IS_ERR(clk)) {
279                 pr_warn("Unable to get timer clock. Assuming 12Mhz input clock.\n");
280                 rate = 12000000;
281         } else {
282                 clk_prepare_enable(clk);
283                 rate = clk_get_rate(clk);
284         }
285
286         /*
287          * rtc registers are used by read_persistent_clock, keep the rtc clock
288          * enabled
289          */
290         clk = clk_get_sys("rtc-tegra", NULL);
291         if (IS_ERR(clk))
292                 pr_warn("Unable to get rtc-tegra clock\n");
293         else
294                 clk_prepare_enable(clk);
295
296         switch (rate) {
297         case 12000000:
298                 timer_writel(0x000b, TIMERUS_USEC_CFG);
299                 break;
300         case 13000000:
301                 timer_writel(0x000c, TIMERUS_USEC_CFG);
302                 break;
303         case 19200000:
304                 timer_writel(0x045f, TIMERUS_USEC_CFG);
305                 break;
306         case 26000000:
307                 timer_writel(0x0019, TIMERUS_USEC_CFG);
308                 break;
309 #ifndef CONFIG_ARCH_TEGRA_2x_SOC
310         case 16800000:
311                 timer_writel(0x0453, TIMERUS_USEC_CFG);
312                 break;
313         case 38400000:
314                 timer_writel(0x04BF, TIMERUS_USEC_CFG);
315                 break;
316         case 48000000:
317                 timer_writel(0x002F, TIMERUS_USEC_CFG);
318                 break;
319 #endif
320         default:
321                 WARN(1, "Unknown clock rate");
322         }
323
324 #ifdef CONFIG_ARCH_TEGRA_2x_SOC
325         tegra20_init_timer();
326 #else
327         tegra30_init_timer();
328 #endif
329
330         setup_sched_clock(tegra_read_sched_clock, 32, 1000000);
331
332         if (clocksource_mmio_init(timer_reg_base + TIMERUS_CNTR_1US,
333                 "timer_us", 1000000, 300, 32, clocksource_mmio_readl_up)) {
334                 pr_err("Failed to register clocksource\n");
335                 BUG();
336         }
337
338         ret = setup_irq(tegra_timer_irq.irq, &tegra_timer_irq);
339         if (ret) {
340                 pr_err("Failed to register timer IRQ: %d\n", ret);
341                 BUG();
342         }
343
344         clockevents_calc_mult_shift(&tegra_clockevent, 1000000, 5);
345         tegra_clockevent.max_delta_ns =
346                 clockevent_delta2ns(0x1fffffff, &tegra_clockevent);
347         tegra_clockevent.min_delta_ns =
348                 clockevent_delta2ns(0x1, &tegra_clockevent);
349         tegra_clockevent.cpumask = cpu_all_mask;
350         tegra_clockevent.irq = tegra_timer_irq.irq;
351         clockevents_register_device(&tegra_clockevent);
352
353         register_syscore_ops(&tegra_timer_syscore_ops);
354         tegra_twd_init();
355
356         register_persistent_clock(NULL, tegra_read_persistent_clock);
357
358         arm_delay_ops.delay             = __tegra_delay;
359         arm_delay_ops.const_udelay      = __tegra_const_udelay;
360         arm_delay_ops.udelay            = __tegra_udelay;
361 }