9e0a1d01743d87a7f8cb9f8423228292f1f8608a
[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         = 425,  /* Must be > dummy_timer and < local_timer */
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 DEFINE_TWD_LOCAL_TIMER(twd_local_timer,
192                               TEGRA_ARM_PERIF_BASE + 0x600,
193                               IRQ_LOCALTIMER);
194
195 static void __init tegra_twd_init(void)
196 {
197         int err = twd_local_timer_register(&twd_local_timer);
198         if (err)
199                 pr_err("twd_local_timer_register failed %d\n", err);
200 }
201
202 int tegra_twd_get_state(struct tegra_twd_context *context)
203 {
204         context->twd_ctrl = readl(twd_base + TWD_TIMER_CONTROL);
205         context->twd_load = readl(twd_base + TWD_TIMER_LOAD);
206         context->twd_cnt = readl(twd_base + TWD_TIMER_COUNTER);
207
208         return 0;
209 }
210
211 void tegra_twd_suspend(struct tegra_twd_context *context)
212 {
213         context->twd_ctrl = readl(twd_base + TWD_TIMER_CONTROL);
214         context->twd_load = readl(twd_base + TWD_TIMER_LOAD);
215         if ((context->twd_load == 0) &&
216             (context->twd_ctrl & TWD_TIMER_CONTROL_PERIODIC) &&
217             (context->twd_ctrl & (TWD_TIMER_CONTROL_ENABLE |
218                                   TWD_TIMER_CONTROL_IT_ENABLE))) {
219                 WARN("%s: TWD enabled but counter was 0\n", __func__);
220                 context->twd_load = 1;
221         }
222         __raw_writel(0, twd_base + TWD_TIMER_CONTROL);
223 }
224
225 void tegra_twd_resume(struct tegra_twd_context *context)
226 {
227         BUG_ON((context->twd_load == 0) &&
228                (context->twd_ctrl & TWD_TIMER_CONTROL_PERIODIC) &&
229                (context->twd_ctrl & (TWD_TIMER_CONTROL_ENABLE |
230                                      TWD_TIMER_CONTROL_IT_ENABLE)));
231         writel(context->twd_load, twd_base + TWD_TIMER_LOAD);
232         writel(context->twd_ctrl, twd_base + TWD_TIMER_CONTROL);
233 }
234 #else
235 #define tegra_twd_init()        do {} while(0)
236 #endif
237
238 extern void __tegra_delay(unsigned long cycles);
239 extern void __tegra_const_udelay(unsigned long loops);
240 extern void __tegra_udelay(unsigned long usecs);
241
242 void __init tegra_init_timer(void)
243 {
244         struct clk *clk;
245         int ret;
246         unsigned long rate;
247
248         clk = clk_get_sys("timer", NULL);
249         if (IS_ERR(clk)) {
250                 pr_warn("Unable to get timer clock. Assuming 12Mhz input clock.\n");
251                 rate = 12000000;
252         } else {
253                 clk_prepare_enable(clk);
254                 rate = clk_get_rate(clk);
255         }
256
257         /*
258          * rtc registers are used by read_persistent_clock, keep the rtc clock
259          * enabled
260          */
261         clk = clk_get_sys("rtc-tegra", NULL);
262         if (IS_ERR(clk))
263                 pr_warn("Unable to get rtc-tegra clock\n");
264         else
265                 clk_prepare_enable(clk);
266
267 #ifdef CONFIG_ARCH_TEGRA_2x_SOC
268         tegra2_init_timer(&system_timer, &tegra_timer_irq.irq, rate);
269 #else
270         tegra3_init_timer(&system_timer, &tegra_timer_irq.irq, rate);
271 #endif
272
273         setup_sched_clock(tegra_read_sched_clock, 32, 1000000);
274
275         if (clocksource_mmio_init(timer_reg_base + TIMERUS_CNTR_1US,
276                 "timer_us", 1000000, 300, 32, clocksource_mmio_readl_up)) {
277                 pr_err("Failed to register clocksource\n");
278                 BUG();
279         }
280
281         ret = setup_irq(tegra_timer_irq.irq, &tegra_timer_irq);
282         if (ret) {
283                 pr_err("Failed to register timer IRQ: %d\n", ret);
284                 BUG();
285         }
286
287         clockevents_calc_mult_shift(&tegra_clockevent, 1000000, 5);
288         tegra_clockevent.max_delta_ns =
289                 clockevent_delta2ns(0x1fffffff, &tegra_clockevent);
290         tegra_clockevent.min_delta_ns =
291                 clockevent_delta2ns(0x1, &tegra_clockevent);
292         tegra_clockevent.cpumask = cpu_all_mask;
293         tegra_clockevent.irq = tegra_timer_irq.irq;
294         clockevents_register_device(&tegra_clockevent);
295
296         tegra_twd_init();
297         register_syscore_ops(&tegra_timer_syscore_ops);
298
299         register_persistent_clock(NULL, tegra_read_persistent_clock);
300
301         arm_delay_ops.delay             = __tegra_delay;
302         arm_delay_ops.const_udelay      = __tegra_const_udelay;
303         arm_delay_ops.udelay            = __tegra_udelay;
304 }