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