1 /* 2 * linux/arch/arm/kernel/smp_twd.c 3 * 4 * Copyright (C) 2002 ARM Ltd. 5 * All Rights Reserved 6 * 7 * This program is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License version 2 as 9 * published by the Free Software Foundation. 10 */ 11 #include <linux/init.h> 12 #include <linux/kernel.h> 13 #include <linux/clk.h> 14 #include <linux/cpu.h> 15 #include <linux/delay.h> 16 #include <linux/device.h> 17 #include <linux/err.h> 18 #include <linux/smp.h> 19 #include <linux/jiffies.h> 20 #include <linux/clockchips.h> 21 #include <linux/interrupt.h> 22 #include <linux/io.h> 23 #include <linux/of_irq.h> 24 #include <linux/of_address.h> 25 26 #include <asm/smp_plat.h> 27 #include <asm/smp_twd.h> 28 29 /* set up by the platform code */ 30 static void __iomem *twd_base; 31 32 static struct clk *twd_clk; 33 static unsigned long twd_timer_rate; 34 static DEFINE_PER_CPU(bool, percpu_setup_called); 35 36 static struct clock_event_device __percpu *twd_evt; 37 static int twd_ppi; 38 39 static int twd_shutdown(struct clock_event_device *clk) 40 { 41 writel_relaxed(0, twd_base + TWD_TIMER_CONTROL); 42 return 0; 43 } 44 45 static int twd_set_oneshot(struct clock_event_device *clk) 46 { 47 /* period set, and timer enabled in 'next_event' hook */ 48 writel_relaxed(TWD_TIMER_CONTROL_IT_ENABLE | TWD_TIMER_CONTROL_ONESHOT, 49 twd_base + TWD_TIMER_CONTROL); 50 return 0; 51 } 52 53 static int twd_set_periodic(struct clock_event_device *clk) 54 { 55 unsigned long ctrl = TWD_TIMER_CONTROL_ENABLE | 56 TWD_TIMER_CONTROL_IT_ENABLE | 57 TWD_TIMER_CONTROL_PERIODIC; 58 59 writel_relaxed(DIV_ROUND_CLOSEST(twd_timer_rate, HZ), 60 twd_base + TWD_TIMER_LOAD); 61 writel_relaxed(ctrl, twd_base + TWD_TIMER_CONTROL); 62 return 0; 63 } 64 65 static int twd_set_next_event(unsigned long evt, 66 struct clock_event_device *unused) 67 { 68 unsigned long ctrl = readl_relaxed(twd_base + TWD_TIMER_CONTROL); 69 70 ctrl |= TWD_TIMER_CONTROL_ENABLE; 71 72 writel_relaxed(evt, twd_base + TWD_TIMER_COUNTER); 73 writel_relaxed(ctrl, twd_base + TWD_TIMER_CONTROL); 74 75 return 0; 76 } 77 78 /* 79 * local_timer_ack: checks for a local timer interrupt. 80 * 81 * If a local timer interrupt has occurred, acknowledge and return 1. 82 * Otherwise, return 0. 83 */ 84 static int twd_timer_ack(void) 85 { 86 if (readl_relaxed(twd_base + TWD_TIMER_INTSTAT)) { 87 writel_relaxed(1, twd_base + TWD_TIMER_INTSTAT); 88 return 1; 89 } 90 91 return 0; 92 } 93 94 static void twd_timer_stop(void) 95 { 96 struct clock_event_device *clk = raw_cpu_ptr(twd_evt); 97 98 twd_shutdown(clk); 99 disable_percpu_irq(clk->irq); 100 } 101 102 #ifdef CONFIG_COMMON_CLK 103 104 /* 105 * Updates clockevent frequency when the cpu frequency changes. 106 * Called on the cpu that is changing frequency with interrupts disabled. 107 */ 108 static void twd_update_frequency(void *new_rate) 109 { 110 twd_timer_rate = *((unsigned long *) new_rate); 111 112 clockevents_update_freq(raw_cpu_ptr(twd_evt), twd_timer_rate); 113 } 114 115 static int twd_rate_change(struct notifier_block *nb, 116 unsigned long flags, void *data) 117 { 118 struct clk_notifier_data *cnd = data; 119 120 /* 121 * The twd clock events must be reprogrammed to account for the new 122 * frequency. The timer is local to a cpu, so cross-call to the 123 * changing cpu. 124 */ 125 if (flags == POST_RATE_CHANGE) 126 on_each_cpu(twd_update_frequency, 127 (void *)&cnd->new_rate, 1); 128 129 return NOTIFY_OK; 130 } 131 132 static struct notifier_block twd_clk_nb = { 133 .notifier_call = twd_rate_change, 134 }; 135 136 static int twd_clk_init(void) 137 { 138 if (twd_evt && raw_cpu_ptr(twd_evt) && !IS_ERR(twd_clk)) 139 return clk_notifier_register(twd_clk, &twd_clk_nb); 140 141 return 0; 142 } 143 core_initcall(twd_clk_init); 144 145 #elif defined (CONFIG_CPU_FREQ) 146 147 #include <linux/cpufreq.h> 148 149 /* 150 * Updates clockevent frequency when the cpu frequency changes. 151 * Called on the cpu that is changing frequency with interrupts disabled. 152 */ 153 static void twd_update_frequency(void *data) 154 { 155 twd_timer_rate = clk_get_rate(twd_clk); 156 157 clockevents_update_freq(raw_cpu_ptr(twd_evt), twd_timer_rate); 158 } 159 160 static int twd_cpufreq_transition(struct notifier_block *nb, 161 unsigned long state, void *data) 162 { 163 struct cpufreq_freqs *freqs = data; 164 165 /* 166 * The twd clock events must be reprogrammed to account for the new 167 * frequency. The timer is local to a cpu, so cross-call to the 168 * changing cpu. 169 */ 170 if (state == CPUFREQ_POSTCHANGE) 171 smp_call_function_single(freqs->cpu, twd_update_frequency, 172 NULL, 1); 173 174 return NOTIFY_OK; 175 } 176 177 static struct notifier_block twd_cpufreq_nb = { 178 .notifier_call = twd_cpufreq_transition, 179 }; 180 181 static int twd_cpufreq_init(void) 182 { 183 if (twd_evt && raw_cpu_ptr(twd_evt) && !IS_ERR(twd_clk)) 184 return cpufreq_register_notifier(&twd_cpufreq_nb, 185 CPUFREQ_TRANSITION_NOTIFIER); 186 187 return 0; 188 } 189 core_initcall(twd_cpufreq_init); 190 191 #endif 192 193 static void twd_calibrate_rate(void) 194 { 195 unsigned long count; 196 u64 waitjiffies; 197 198 /* 199 * If this is the first time round, we need to work out how fast 200 * the timer ticks 201 */ 202 if (twd_timer_rate == 0) { 203 pr_info("Calibrating local timer... "); 204 205 /* Wait for a tick to start */ 206 waitjiffies = get_jiffies_64() + 1; 207 208 while (get_jiffies_64() < waitjiffies) 209 udelay(10); 210 211 /* OK, now the tick has started, let's get the timer going */ 212 waitjiffies += 5; 213 214 /* enable, no interrupt or reload */ 215 writel_relaxed(0x1, twd_base + TWD_TIMER_CONTROL); 216 217 /* maximum value */ 218 writel_relaxed(0xFFFFFFFFU, twd_base + TWD_TIMER_COUNTER); 219 220 while (get_jiffies_64() < waitjiffies) 221 udelay(10); 222 223 count = readl_relaxed(twd_base + TWD_TIMER_COUNTER); 224 225 twd_timer_rate = (0xFFFFFFFFU - count) * (HZ / 5); 226 227 pr_cont("%lu.%02luMHz.\n", twd_timer_rate / 1000000, 228 (twd_timer_rate / 10000) % 100); 229 } 230 } 231 232 static irqreturn_t twd_handler(int irq, void *dev_id) 233 { 234 struct clock_event_device *evt = dev_id; 235 236 if (twd_timer_ack()) { 237 evt->event_handler(evt); 238 return IRQ_HANDLED; 239 } 240 241 return IRQ_NONE; 242 } 243 244 static void twd_get_clock(struct device_node *np) 245 { 246 int err; 247 248 if (np) 249 twd_clk = of_clk_get(np, 0); 250 else 251 twd_clk = clk_get_sys("smp_twd", NULL); 252 253 if (IS_ERR(twd_clk)) { 254 pr_err("smp_twd: clock not found %d\n", (int) PTR_ERR(twd_clk)); 255 return; 256 } 257 258 err = clk_prepare_enable(twd_clk); 259 if (err) { 260 pr_err("smp_twd: clock failed to prepare+enable: %d\n", err); 261 clk_put(twd_clk); 262 return; 263 } 264 265 twd_timer_rate = clk_get_rate(twd_clk); 266 } 267 268 /* 269 * Setup the local clock events for a CPU. 270 */ 271 static void twd_timer_setup(void) 272 { 273 struct clock_event_device *clk = raw_cpu_ptr(twd_evt); 274 int cpu = smp_processor_id(); 275 276 /* 277 * If the basic setup for this CPU has been done before don't 278 * bother with the below. 279 */ 280 if (per_cpu(percpu_setup_called, cpu)) { 281 writel_relaxed(0, twd_base + TWD_TIMER_CONTROL); 282 clockevents_register_device(clk); 283 enable_percpu_irq(clk->irq, 0); 284 return; 285 } 286 per_cpu(percpu_setup_called, cpu) = true; 287 288 twd_calibrate_rate(); 289 290 /* 291 * The following is done once per CPU the first time .setup() is 292 * called. 293 */ 294 writel_relaxed(0, twd_base + TWD_TIMER_CONTROL); 295 296 clk->name = "local_timer"; 297 clk->features = CLOCK_EVT_FEAT_PERIODIC | CLOCK_EVT_FEAT_ONESHOT | 298 CLOCK_EVT_FEAT_C3STOP; 299 clk->rating = 350; 300 clk->set_state_shutdown = twd_shutdown; 301 clk->set_state_periodic = twd_set_periodic; 302 clk->set_state_oneshot = twd_set_oneshot; 303 clk->tick_resume = twd_shutdown; 304 clk->set_next_event = twd_set_next_event; 305 clk->irq = twd_ppi; 306 clk->cpumask = cpumask_of(cpu); 307 308 clockevents_config_and_register(clk, twd_timer_rate, 309 0xf, 0xffffffff); 310 enable_percpu_irq(clk->irq, 0); 311 } 312 313 static int twd_timer_cpu_notify(struct notifier_block *self, 314 unsigned long action, void *hcpu) 315 { 316 switch (action & ~CPU_TASKS_FROZEN) { 317 case CPU_STARTING: 318 twd_timer_setup(); 319 break; 320 case CPU_DYING: 321 twd_timer_stop(); 322 break; 323 } 324 325 return NOTIFY_OK; 326 } 327 328 static struct notifier_block twd_timer_cpu_nb = { 329 .notifier_call = twd_timer_cpu_notify, 330 }; 331 332 static int __init twd_local_timer_common_register(struct device_node *np) 333 { 334 int err; 335 336 twd_evt = alloc_percpu(struct clock_event_device); 337 if (!twd_evt) { 338 err = -ENOMEM; 339 goto out_free; 340 } 341 342 err = request_percpu_irq(twd_ppi, twd_handler, "twd", twd_evt); 343 if (err) { 344 pr_err("twd: can't register interrupt %d (%d)\n", twd_ppi, err); 345 goto out_free; 346 } 347 348 err = register_cpu_notifier(&twd_timer_cpu_nb); 349 if (err) 350 goto out_irq; 351 352 twd_get_clock(np); 353 354 /* 355 * Immediately configure the timer on the boot CPU, unless we need 356 * jiffies to be incrementing to calibrate the rate in which case 357 * setup the timer in late_time_init. 358 */ 359 if (twd_timer_rate) 360 twd_timer_setup(); 361 else 362 late_time_init = twd_timer_setup; 363 364 return 0; 365 366 out_irq: 367 free_percpu_irq(twd_ppi, twd_evt); 368 out_free: 369 iounmap(twd_base); 370 twd_base = NULL; 371 free_percpu(twd_evt); 372 373 return err; 374 } 375 376 int __init twd_local_timer_register(struct twd_local_timer *tlt) 377 { 378 if (twd_base || twd_evt) 379 return -EBUSY; 380 381 twd_ppi = tlt->res[1].start; 382 383 twd_base = ioremap(tlt->res[0].start, resource_size(&tlt->res[0])); 384 if (!twd_base) 385 return -ENOMEM; 386 387 return twd_local_timer_common_register(NULL); 388 } 389 390 #ifdef CONFIG_OF 391 static void __init twd_local_timer_of_register(struct device_node *np) 392 { 393 int err; 394 395 if (!is_smp() || !setup_max_cpus) 396 return; 397 398 twd_ppi = irq_of_parse_and_map(np, 0); 399 if (!twd_ppi) { 400 err = -EINVAL; 401 goto out; 402 } 403 404 twd_base = of_iomap(np, 0); 405 if (!twd_base) { 406 err = -ENOMEM; 407 goto out; 408 } 409 410 err = twd_local_timer_common_register(np); 411 412 out: 413 WARN(err, "twd_local_timer_of_register failed (%d)\n", err); 414 } 415 CLOCKSOURCE_OF_DECLARE(arm_twd_a9, "arm,cortex-a9-twd-timer", twd_local_timer_of_register); 416 CLOCKSOURCE_OF_DECLARE(arm_twd_a5, "arm,cortex-a5-twd-timer", twd_local_timer_of_register); 417 CLOCKSOURCE_OF_DECLARE(arm_twd_11mp, "arm,arm11mp-twd-timer", twd_local_timer_of_register); 418 #endif 419