Stephen Boyd | dd15ab8 | 2011-11-08 10:34:05 -0800 | [diff] [blame^] | 1 | /* |
Arve Hjønnevåg | 3e4ea37 | 2007-11-26 04:11:58 -0800 | [diff] [blame] | 2 | * |
| 3 | * Copyright (C) 2007 Google, Inc. |
Stephen Boyd | dd15ab8 | 2011-11-08 10:34:05 -0800 | [diff] [blame^] | 4 | * Copyright (c) 2009-2011, Code Aurora Forum. All rights reserved. |
Arve Hjønnevåg | 3e4ea37 | 2007-11-26 04:11:58 -0800 | [diff] [blame] | 5 | * |
| 6 | * This software is licensed under the terms of the GNU General Public |
| 7 | * License version 2, as published by the Free Software Foundation, and |
| 8 | * may be copied, distributed, and modified under those terms. |
| 9 | * |
| 10 | * This program is distributed in the hope that it will be useful, |
| 11 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 12 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 13 | * GNU General Public License for more details. |
| 14 | * |
| 15 | */ |
| 16 | |
Stephen Boyd | 4a18407 | 2011-11-08 10:34:04 -0800 | [diff] [blame] | 17 | #include <linux/clocksource.h> |
| 18 | #include <linux/clockchips.h> |
Arve Hjønnevåg | 3e4ea37 | 2007-11-26 04:11:58 -0800 | [diff] [blame] | 19 | #include <linux/init.h> |
Arve Hjønnevåg | 3e4ea37 | 2007-11-26 04:11:58 -0800 | [diff] [blame] | 20 | #include <linux/interrupt.h> |
| 21 | #include <linux/irq.h> |
Russell King | fced80c | 2008-09-06 12:10:45 +0100 | [diff] [blame] | 22 | #include <linux/io.h> |
Arve Hjønnevåg | 3e4ea37 | 2007-11-26 04:11:58 -0800 | [diff] [blame] | 23 | |
| 24 | #include <asm/mach/time.h> |
Stephen Boyd | ebf30dc | 2011-05-31 16:10:00 -0700 | [diff] [blame] | 25 | #include <asm/hardware/gic.h> |
Stephen Boyd | 4a18407 | 2011-11-08 10:34:04 -0800 | [diff] [blame] | 26 | #include <asm/localtimer.h> |
Stephen Boyd | ebf30dc | 2011-05-31 16:10:00 -0700 | [diff] [blame] | 27 | |
Russell King | a09e64f | 2008-08-05 16:14:15 +0100 | [diff] [blame] | 28 | #include <mach/msm_iomap.h> |
David Brown | 8c27e6f | 2011-01-07 10:20:49 -0800 | [diff] [blame] | 29 | #include <mach/cpu.h> |
Stephen Boyd | 4a18407 | 2011-11-08 10:34:04 -0800 | [diff] [blame] | 30 | #include <mach/board.h> |
Arve Hjønnevåg | 3e4ea37 | 2007-11-26 04:11:58 -0800 | [diff] [blame] | 31 | |
| 32 | #define TIMER_MATCH_VAL 0x0000 |
| 33 | #define TIMER_COUNT_VAL 0x0004 |
| 34 | #define TIMER_ENABLE 0x0008 |
Stephen Boyd | 4a18407 | 2011-11-08 10:34:04 -0800 | [diff] [blame] | 35 | #define TIMER_ENABLE_CLR_ON_MATCH_EN BIT(1) |
| 36 | #define TIMER_ENABLE_EN BIT(0) |
Arve Hjønnevåg | 3e4ea37 | 2007-11-26 04:11:58 -0800 | [diff] [blame] | 37 | #define TIMER_CLEAR 0x000C |
Jeff Ohlstein | 672039f | 2010-10-05 15:23:57 -0700 | [diff] [blame] | 38 | #define DGT_CLK_CTL 0x0034 |
Stephen Boyd | 4a18407 | 2011-11-08 10:34:04 -0800 | [diff] [blame] | 39 | #define DGT_CLK_CTL_DIV_4 0x3 |
Arve Hjønnevåg | 3e4ea37 | 2007-11-26 04:11:58 -0800 | [diff] [blame] | 40 | |
| 41 | #define GPT_HZ 32768 |
Jeff Ohlstein | 672039f | 2010-10-05 15:23:57 -0700 | [diff] [blame] | 42 | |
Stephen Boyd | dd15ab8 | 2011-11-08 10:34:05 -0800 | [diff] [blame^] | 43 | #define MSM_GLOBAL_TIMER MSM_CLOCK_GPT |
Jeff Ohlstein | 94790ec | 2010-12-02 12:05:12 -0800 | [diff] [blame] | 44 | |
David Brown | 8c27e6f | 2011-01-07 10:20:49 -0800 | [diff] [blame] | 45 | /* TODO: Remove these ifdefs */ |
Jeff Ohlstein | 672039f | 2010-10-05 15:23:57 -0700 | [diff] [blame] | 46 | #if defined(CONFIG_ARCH_QSD8X50) |
| 47 | #define DGT_HZ (19200000 / 4) /* 19.2 MHz / 4 by default */ |
| 48 | #define MSM_DGT_SHIFT (0) |
Stephen Boyd | fdb9c3c | 2011-04-21 23:09:11 +0000 | [diff] [blame] | 49 | #elif defined(CONFIG_ARCH_MSM7X30) |
Jeff Ohlstein | 672039f | 2010-10-05 15:23:57 -0700 | [diff] [blame] | 50 | #define DGT_HZ (24576000 / 4) /* 24.576 MHz (LPXO) / 4 by default */ |
| 51 | #define MSM_DGT_SHIFT (0) |
Stephen Boyd | fdb9c3c | 2011-04-21 23:09:11 +0000 | [diff] [blame] | 52 | #elif defined(CONFIG_ARCH_MSM8X60) || defined(CONFIG_ARCH_MSM8960) |
| 53 | #define DGT_HZ (27000000 / 4) /* 27 MHz (PXO) / 4 by default */ |
| 54 | #define MSM_DGT_SHIFT (0) |
Jeff Ohlstein | 672039f | 2010-10-05 15:23:57 -0700 | [diff] [blame] | 55 | #else |
Arve Hjønnevåg | 3e4ea37 | 2007-11-26 04:11:58 -0800 | [diff] [blame] | 56 | #define DGT_HZ 19200000 /* 19.2 MHz or 600 KHz after shift */ |
Jeff Ohlstein | 672039f | 2010-10-05 15:23:57 -0700 | [diff] [blame] | 57 | #define MSM_DGT_SHIFT (5) |
| 58 | #endif |
Arve Hjønnevåg | 3e4ea37 | 2007-11-26 04:11:58 -0800 | [diff] [blame] | 59 | |
| 60 | struct msm_clock { |
| 61 | struct clock_event_device clockevent; |
| 62 | struct clocksource clocksource; |
Marc Zyngier | 28af690 | 2011-07-22 12:52:37 +0100 | [diff] [blame] | 63 | unsigned int irq; |
Brian Swetland | bcc0f6a | 2008-09-10 14:00:53 -0700 | [diff] [blame] | 64 | void __iomem *regbase; |
Arve Hjønnevåg | 3e4ea37 | 2007-11-26 04:11:58 -0800 | [diff] [blame] | 65 | uint32_t freq; |
| 66 | uint32_t shift; |
Jeff Ohlstein | 94790ec | 2010-12-02 12:05:12 -0800 | [diff] [blame] | 67 | void __iomem *global_counter; |
| 68 | void __iomem *local_counter; |
Marc Zyngier | 28af690 | 2011-07-22 12:52:37 +0100 | [diff] [blame] | 69 | union { |
| 70 | struct clock_event_device *evt; |
| 71 | struct clock_event_device __percpu **percpu_evt; |
| 72 | }; |
Arve Hjønnevåg | 3e4ea37 | 2007-11-26 04:11:58 -0800 | [diff] [blame] | 73 | }; |
| 74 | |
Jeff Ohlstein | 94790ec | 2010-12-02 12:05:12 -0800 | [diff] [blame] | 75 | enum { |
| 76 | MSM_CLOCK_GPT, |
| 77 | MSM_CLOCK_DGT, |
| 78 | NR_TIMERS, |
| 79 | }; |
| 80 | |
| 81 | |
| 82 | static struct msm_clock msm_clocks[]; |
Jeff Ohlstein | 94790ec | 2010-12-02 12:05:12 -0800 | [diff] [blame] | 83 | |
Arve Hjønnevåg | 3e4ea37 | 2007-11-26 04:11:58 -0800 | [diff] [blame] | 84 | static irqreturn_t msm_timer_interrupt(int irq, void *dev_id) |
| 85 | { |
Marc Zyngier | 28af690 | 2011-07-22 12:52:37 +0100 | [diff] [blame] | 86 | struct clock_event_device *evt = *(struct clock_event_device **)dev_id; |
Jeff Ohlstein | 94790ec | 2010-12-02 12:05:12 -0800 | [diff] [blame] | 87 | if (evt->event_handler == NULL) |
| 88 | return IRQ_HANDLED; |
Arve Hjønnevåg | 3e4ea37 | 2007-11-26 04:11:58 -0800 | [diff] [blame] | 89 | evt->event_handler(evt); |
| 90 | return IRQ_HANDLED; |
| 91 | } |
| 92 | |
Jeff Ohlstein | 94790ec | 2010-12-02 12:05:12 -0800 | [diff] [blame] | 93 | static cycle_t msm_read_timer_count(struct clocksource *cs) |
Arve Hjønnevåg | 3e4ea37 | 2007-11-26 04:11:58 -0800 | [diff] [blame] | 94 | { |
Jeff Ohlstein | 94790ec | 2010-12-02 12:05:12 -0800 | [diff] [blame] | 95 | struct msm_clock *clk = container_of(cs, struct msm_clock, clocksource); |
| 96 | |
Jeff Ohlstein | 650f156 | 2011-06-17 13:55:38 -0700 | [diff] [blame] | 97 | /* |
| 98 | * Shift timer count down by a constant due to unreliable lower bits |
| 99 | * on some targets. |
| 100 | */ |
| 101 | return readl(clk->global_counter) >> clk->shift; |
Arve Hjønnevåg | 3e4ea37 | 2007-11-26 04:11:58 -0800 | [diff] [blame] | 102 | } |
| 103 | |
Jeff Ohlstein | 94790ec | 2010-12-02 12:05:12 -0800 | [diff] [blame] | 104 | static struct msm_clock *clockevent_to_clock(struct clock_event_device *evt) |
Arve Hjønnevåg | 3e4ea37 | 2007-11-26 04:11:58 -0800 | [diff] [blame] | 105 | { |
Jeff Ohlstein | 94790ec | 2010-12-02 12:05:12 -0800 | [diff] [blame] | 106 | #ifdef CONFIG_SMP |
| 107 | int i; |
| 108 | for (i = 0; i < NR_TIMERS; i++) |
| 109 | if (evt == &(msm_clocks[i].clockevent)) |
| 110 | return &msm_clocks[i]; |
| 111 | return &msm_clocks[MSM_GLOBAL_TIMER]; |
| 112 | #else |
| 113 | return container_of(evt, struct msm_clock, clockevent); |
| 114 | #endif |
Arve Hjønnevåg | 3e4ea37 | 2007-11-26 04:11:58 -0800 | [diff] [blame] | 115 | } |
| 116 | |
| 117 | static int msm_timer_set_next_event(unsigned long cycles, |
| 118 | struct clock_event_device *evt) |
| 119 | { |
Jeff Ohlstein | 94790ec | 2010-12-02 12:05:12 -0800 | [diff] [blame] | 120 | struct msm_clock *clock = clockevent_to_clock(evt); |
| 121 | uint32_t now = readl(clock->local_counter); |
Arve Hjønnevåg | 3e4ea37 | 2007-11-26 04:11:58 -0800 | [diff] [blame] | 122 | uint32_t alarm = now + (cycles << clock->shift); |
Arve Hjønnevåg | 3e4ea37 | 2007-11-26 04:11:58 -0800 | [diff] [blame] | 123 | |
| 124 | writel(alarm, clock->regbase + TIMER_MATCH_VAL); |
Arve Hjønnevåg | 3e4ea37 | 2007-11-26 04:11:58 -0800 | [diff] [blame] | 125 | return 0; |
| 126 | } |
| 127 | |
| 128 | static void msm_timer_set_mode(enum clock_event_mode mode, |
| 129 | struct clock_event_device *evt) |
| 130 | { |
Jeff Ohlstein | 94790ec | 2010-12-02 12:05:12 -0800 | [diff] [blame] | 131 | struct msm_clock *clock = clockevent_to_clock(evt); |
| 132 | |
Arve Hjønnevåg | 3e4ea37 | 2007-11-26 04:11:58 -0800 | [diff] [blame] | 133 | switch (mode) { |
| 134 | case CLOCK_EVT_MODE_RESUME: |
| 135 | case CLOCK_EVT_MODE_PERIODIC: |
| 136 | break; |
| 137 | case CLOCK_EVT_MODE_ONESHOT: |
| 138 | writel(TIMER_ENABLE_EN, clock->regbase + TIMER_ENABLE); |
| 139 | break; |
| 140 | case CLOCK_EVT_MODE_UNUSED: |
| 141 | case CLOCK_EVT_MODE_SHUTDOWN: |
| 142 | writel(0, clock->regbase + TIMER_ENABLE); |
| 143 | break; |
| 144 | } |
| 145 | } |
| 146 | |
| 147 | static struct msm_clock msm_clocks[] = { |
Jeff Ohlstein | 94790ec | 2010-12-02 12:05:12 -0800 | [diff] [blame] | 148 | [MSM_CLOCK_GPT] = { |
Arve Hjønnevåg | 3e4ea37 | 2007-11-26 04:11:58 -0800 | [diff] [blame] | 149 | .clockevent = { |
| 150 | .name = "gp_timer", |
| 151 | .features = CLOCK_EVT_FEAT_ONESHOT, |
| 152 | .shift = 32, |
| 153 | .rating = 200, |
| 154 | .set_next_event = msm_timer_set_next_event, |
| 155 | .set_mode = msm_timer_set_mode, |
| 156 | }, |
Marc Zyngier | 28af690 | 2011-07-22 12:52:37 +0100 | [diff] [blame] | 157 | .irq = INT_GP_TIMER_EXP, |
Jeff Ohlstein | 94790ec | 2010-12-02 12:05:12 -0800 | [diff] [blame] | 158 | .freq = GPT_HZ, |
Arve Hjønnevåg | 3e4ea37 | 2007-11-26 04:11:58 -0800 | [diff] [blame] | 159 | }, |
Jeff Ohlstein | 94790ec | 2010-12-02 12:05:12 -0800 | [diff] [blame] | 160 | [MSM_CLOCK_DGT] = { |
Arve Hjønnevåg | 3e4ea37 | 2007-11-26 04:11:58 -0800 | [diff] [blame] | 161 | .clocksource = { |
| 162 | .name = "dg_timer", |
| 163 | .rating = 300, |
Jeff Ohlstein | 94790ec | 2010-12-02 12:05:12 -0800 | [diff] [blame] | 164 | .read = msm_read_timer_count, |
Arve Hjønnevåg | 3e4ea37 | 2007-11-26 04:11:58 -0800 | [diff] [blame] | 165 | .mask = CLOCKSOURCE_MASK((32 - MSM_DGT_SHIFT)), |
Arve Hjønnevåg | 3e4ea37 | 2007-11-26 04:11:58 -0800 | [diff] [blame] | 166 | .flags = CLOCK_SOURCE_IS_CONTINUOUS, |
| 167 | }, |
Arve Hjønnevåg | 3e4ea37 | 2007-11-26 04:11:58 -0800 | [diff] [blame] | 168 | .freq = DGT_HZ >> MSM_DGT_SHIFT, |
Jeff Ohlstein | 94790ec | 2010-12-02 12:05:12 -0800 | [diff] [blame] | 169 | .shift = MSM_DGT_SHIFT, |
Arve Hjønnevåg | 3e4ea37 | 2007-11-26 04:11:58 -0800 | [diff] [blame] | 170 | } |
| 171 | }; |
| 172 | |
| 173 | static void __init msm_timer_init(void) |
| 174 | { |
Stephen Boyd | dd15ab8 | 2011-11-08 10:34:05 -0800 | [diff] [blame^] | 175 | struct msm_clock *clock; |
| 176 | struct clock_event_device *ce = &msm_clocks[MSM_CLOCK_GPT].clockevent; |
| 177 | struct clocksource *cs = &msm_clocks[MSM_CLOCK_DGT].clocksource; |
Arve Hjønnevåg | 3e4ea37 | 2007-11-26 04:11:58 -0800 | [diff] [blame] | 178 | int res; |
David Brown | 8c27e6f | 2011-01-07 10:20:49 -0800 | [diff] [blame] | 179 | int global_offset = 0; |
| 180 | |
Stephen Boyd | dd15ab8 | 2011-11-08 10:34:05 -0800 | [diff] [blame^] | 181 | |
David Brown | 8c27e6f | 2011-01-07 10:20:49 -0800 | [diff] [blame] | 182 | if (cpu_is_msm7x01()) { |
| 183 | msm_clocks[MSM_CLOCK_GPT].regbase = MSM_CSR_BASE; |
| 184 | msm_clocks[MSM_CLOCK_DGT].regbase = MSM_CSR_BASE + 0x10; |
| 185 | } else if (cpu_is_msm7x30()) { |
| 186 | msm_clocks[MSM_CLOCK_GPT].regbase = MSM_CSR_BASE + 0x04; |
| 187 | msm_clocks[MSM_CLOCK_DGT].regbase = MSM_CSR_BASE + 0x24; |
| 188 | } else if (cpu_is_qsd8x50()) { |
| 189 | msm_clocks[MSM_CLOCK_GPT].regbase = MSM_CSR_BASE; |
| 190 | msm_clocks[MSM_CLOCK_DGT].regbase = MSM_CSR_BASE + 0x10; |
Stepan Moskovchenko | a81c8c3 | 2010-12-01 19:25:14 -0800 | [diff] [blame] | 191 | } else if (cpu_is_msm8x60() || cpu_is_msm8960()) { |
David Brown | 8c27e6f | 2011-01-07 10:20:49 -0800 | [diff] [blame] | 192 | msm_clocks[MSM_CLOCK_GPT].regbase = MSM_TMR_BASE + 0x04; |
| 193 | msm_clocks[MSM_CLOCK_DGT].regbase = MSM_TMR_BASE + 0x24; |
| 194 | |
| 195 | /* Use CPU0's timer as the global timer. */ |
| 196 | global_offset = MSM_TMR0_BASE - MSM_TMR_BASE; |
| 197 | } else |
| 198 | BUG(); |
Arve Hjønnevåg | 3e4ea37 | 2007-11-26 04:11:58 -0800 | [diff] [blame] | 199 | |
Jeff Ohlstein | 94790ec | 2010-12-02 12:05:12 -0800 | [diff] [blame] | 200 | #ifdef CONFIG_ARCH_MSM_SCORPIONMP |
Jeff Ohlstein | 672039f | 2010-10-05 15:23:57 -0700 | [diff] [blame] | 201 | writel(DGT_CLK_CTL_DIV_4, MSM_TMR_BASE + DGT_CLK_CTL); |
| 202 | #endif |
| 203 | |
Stephen Boyd | dd15ab8 | 2011-11-08 10:34:05 -0800 | [diff] [blame^] | 204 | clock = &msm_clocks[MSM_CLOCK_GPT]; |
| 205 | clock->local_counter = clock->regbase + TIMER_COUNT_VAL; |
David Brown | 8c27e6f | 2011-01-07 10:20:49 -0800 | [diff] [blame] | 206 | |
Stephen Boyd | dd15ab8 | 2011-11-08 10:34:05 -0800 | [diff] [blame^] | 207 | writel_relaxed(0, clock->regbase + TIMER_ENABLE); |
| 208 | writel_relaxed(0, clock->regbase + TIMER_CLEAR); |
| 209 | writel_relaxed(~0, clock->regbase + TIMER_MATCH_VAL); |
| 210 | ce->mult = div_sc(clock->freq, NSEC_PER_SEC, ce->shift); |
| 211 | /* |
| 212 | * allow at least 10 seconds to notice that the timer |
| 213 | * wrapped |
| 214 | */ |
| 215 | ce->max_delta_ns = |
| 216 | clockevent_delta2ns(0xf0000000 >> clock->shift, ce); |
| 217 | /* 4 gets rounded down to 3 */ |
| 218 | ce->min_delta_ns = clockevent_delta2ns(4, ce); |
| 219 | ce->cpumask = cpumask_of(0); |
David Brown | 8c27e6f | 2011-01-07 10:20:49 -0800 | [diff] [blame] | 220 | |
Stephen Boyd | dd15ab8 | 2011-11-08 10:34:05 -0800 | [diff] [blame^] | 221 | ce->irq = clock->irq; |
| 222 | if (cpu_is_msm8x60() || cpu_is_msm8960()) { |
| 223 | clock->percpu_evt = alloc_percpu(struct clock_event_device *); |
| 224 | if (!clock->percpu_evt) { |
| 225 | pr_err("memory allocation failed for %s\n", ce->name); |
| 226 | goto err; |
Marc Zyngier | 28af690 | 2011-07-22 12:52:37 +0100 | [diff] [blame] | 227 | } |
| 228 | |
Stephen Boyd | dd15ab8 | 2011-11-08 10:34:05 -0800 | [diff] [blame^] | 229 | *__this_cpu_ptr(clock->percpu_evt) = ce; |
| 230 | res = request_percpu_irq(ce->irq, msm_timer_interrupt, |
| 231 | ce->name, clock->percpu_evt); |
| 232 | if (!res) |
| 233 | enable_percpu_irq(ce->irq, 0); |
| 234 | } else { |
| 235 | clock->evt = ce; |
| 236 | res = request_irq(ce->irq, msm_timer_interrupt, |
| 237 | IRQF_TIMER | IRQF_NOBALANCING | |
| 238 | IRQF_TRIGGER_RISING, ce->name, &clock->evt); |
Arve Hjønnevåg | 3e4ea37 | 2007-11-26 04:11:58 -0800 | [diff] [blame] | 239 | } |
Stephen Boyd | dd15ab8 | 2011-11-08 10:34:05 -0800 | [diff] [blame^] | 240 | |
| 241 | if (res) |
| 242 | pr_err("request_irq failed for %s\n", ce->name); |
| 243 | |
| 244 | clockevents_register_device(ce); |
| 245 | err: |
| 246 | clock = &msm_clocks[MSM_CLOCK_DGT]; |
| 247 | clock->local_counter = clock->regbase + TIMER_COUNT_VAL; |
| 248 | clock->global_counter = clock->local_counter + global_offset; |
| 249 | writel_relaxed(TIMER_ENABLE_EN, clock->regbase + TIMER_ENABLE); |
| 250 | res = clocksource_register_hz(cs, clock->freq); |
| 251 | if (res) |
| 252 | pr_err("clocksource_register failed for %s\n", cs->name); |
Arve Hjønnevåg | 3e4ea37 | 2007-11-26 04:11:58 -0800 | [diff] [blame] | 253 | } |
| 254 | |
Stephen Boyd | 2852cca | 2011-11-08 10:34:03 -0800 | [diff] [blame] | 255 | #ifdef CONFIG_LOCAL_TIMERS |
Santosh Shilimkar | af90f10 | 2011-02-23 18:53:15 +0100 | [diff] [blame] | 256 | int __cpuinit local_timer_setup(struct clock_event_device *evt) |
Jeff Ohlstein | 94790ec | 2010-12-02 12:05:12 -0800 | [diff] [blame] | 257 | { |
Marc Zyngier | 28af690 | 2011-07-22 12:52:37 +0100 | [diff] [blame] | 258 | static bool local_timer_inited; |
Jeff Ohlstein | 94790ec | 2010-12-02 12:05:12 -0800 | [diff] [blame] | 259 | struct msm_clock *clock = &msm_clocks[MSM_GLOBAL_TIMER]; |
| 260 | |
| 261 | /* Use existing clock_event for cpu 0 */ |
| 262 | if (!smp_processor_id()) |
David Brown | 893b66c | 2011-03-30 11:26:57 -0700 | [diff] [blame] | 263 | return 0; |
Jeff Ohlstein | 94790ec | 2010-12-02 12:05:12 -0800 | [diff] [blame] | 264 | |
Marc Zyngier | 28af690 | 2011-07-22 12:52:37 +0100 | [diff] [blame] | 265 | if (!local_timer_inited) { |
Jeff Ohlstein | 94790ec | 2010-12-02 12:05:12 -0800 | [diff] [blame] | 266 | writel(0, clock->regbase + TIMER_ENABLE); |
| 267 | writel(0, clock->regbase + TIMER_CLEAR); |
| 268 | writel(~0, clock->regbase + TIMER_MATCH_VAL); |
Marc Zyngier | 28af690 | 2011-07-22 12:52:37 +0100 | [diff] [blame] | 269 | local_timer_inited = true; |
Jeff Ohlstein | 94790ec | 2010-12-02 12:05:12 -0800 | [diff] [blame] | 270 | } |
Marc Zyngier | 28af690 | 2011-07-22 12:52:37 +0100 | [diff] [blame] | 271 | evt->irq = clock->irq; |
Jeff Ohlstein | 94790ec | 2010-12-02 12:05:12 -0800 | [diff] [blame] | 272 | evt->name = "local_timer"; |
| 273 | evt->features = CLOCK_EVT_FEAT_ONESHOT; |
| 274 | evt->rating = clock->clockevent.rating; |
| 275 | evt->set_mode = msm_timer_set_mode; |
| 276 | evt->set_next_event = msm_timer_set_next_event; |
| 277 | evt->shift = clock->clockevent.shift; |
| 278 | evt->mult = div_sc(clock->freq, NSEC_PER_SEC, evt->shift); |
| 279 | evt->max_delta_ns = |
| 280 | clockevent_delta2ns(0xf0000000 >> clock->shift, evt); |
| 281 | evt->min_delta_ns = clockevent_delta2ns(4, evt); |
| 282 | |
Marc Zyngier | 28af690 | 2011-07-22 12:52:37 +0100 | [diff] [blame] | 283 | *__this_cpu_ptr(clock->percpu_evt) = evt; |
| 284 | enable_percpu_irq(evt->irq, 0); |
Jeff Ohlstein | 94790ec | 2010-12-02 12:05:12 -0800 | [diff] [blame] | 285 | |
| 286 | clockevents_register_device(evt); |
Santosh Shilimkar | af90f10 | 2011-02-23 18:53:15 +0100 | [diff] [blame] | 287 | return 0; |
Jeff Ohlstein | 94790ec | 2010-12-02 12:05:12 -0800 | [diff] [blame] | 288 | } |
| 289 | |
Marc Zyngier | 28af690 | 2011-07-22 12:52:37 +0100 | [diff] [blame] | 290 | void local_timer_stop(struct clock_event_device *evt) |
Jeff Ohlstein | 94790ec | 2010-12-02 12:05:12 -0800 | [diff] [blame] | 291 | { |
Marc Zyngier | 28af690 | 2011-07-22 12:52:37 +0100 | [diff] [blame] | 292 | evt->set_mode(CLOCK_EVT_MODE_UNUSED, evt); |
| 293 | disable_percpu_irq(evt->irq); |
Jeff Ohlstein | 94790ec | 2010-12-02 12:05:12 -0800 | [diff] [blame] | 294 | } |
Stephen Boyd | 2852cca | 2011-11-08 10:34:03 -0800 | [diff] [blame] | 295 | #endif /* CONFIG_LOCAL_TIMERS */ |
Jeff Ohlstein | 94790ec | 2010-12-02 12:05:12 -0800 | [diff] [blame] | 296 | |
Arve Hjønnevåg | 3e4ea37 | 2007-11-26 04:11:58 -0800 | [diff] [blame] | 297 | struct sys_timer msm_timer = { |
| 298 | .init = msm_timer_init |
| 299 | }; |