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