Tony Lindgren | 1dbae81 | 2005-11-10 14:26:51 +0000 | [diff] [blame] | 1 | /* |
Tony Lindgren | 0f622e8 | 2011-03-29 15:54:50 -0700 | [diff] [blame] | 2 | * linux/arch/arm/mach-omap2/timer.c |
Tony Lindgren | 1dbae81 | 2005-11-10 14:26:51 +0000 | [diff] [blame] | 3 | * |
| 4 | * OMAP2 GP timer support. |
| 5 | * |
Paul Walmsley | f248076 | 2009-04-23 21:11:10 -0600 | [diff] [blame] | 6 | * Copyright (C) 2009 Nokia Corporation |
| 7 | * |
Kevin Hilman | 5a3a388 | 2007-11-12 23:24:02 -0800 | [diff] [blame] | 8 | * Update to use new clocksource/clockevent layers |
| 9 | * Author: Kevin Hilman, MontaVista Software, Inc. <source@mvista.com> |
| 10 | * Copyright (C) 2007 MontaVista Software, Inc. |
| 11 | * |
| 12 | * Original driver: |
Tony Lindgren | 1dbae81 | 2005-11-10 14:26:51 +0000 | [diff] [blame] | 13 | * Copyright (C) 2005 Nokia Corporation |
| 14 | * Author: Paul Mundt <paul.mundt@nokia.com> |
Jan Engelhardt | 96de0e2 | 2007-10-19 23:21:04 +0200 | [diff] [blame] | 15 | * Juha Yrjölä <juha.yrjola@nokia.com> |
Timo Teras | 77900a2 | 2006-06-26 16:16:12 -0700 | [diff] [blame] | 16 | * OMAP Dual-mode timer framework support by Timo Teras |
Tony Lindgren | 1dbae81 | 2005-11-10 14:26:51 +0000 | [diff] [blame] | 17 | * |
| 18 | * Some parts based off of TI's 24xx code: |
| 19 | * |
Santosh Shilimkar | 4416907 | 2009-05-28 14:16:04 -0700 | [diff] [blame] | 20 | * Copyright (C) 2004-2009 Texas Instruments, Inc. |
Tony Lindgren | 1dbae81 | 2005-11-10 14:26:51 +0000 | [diff] [blame] | 21 | * |
| 22 | * Roughly modelled after the OMAP1 MPU timer code. |
Santosh Shilimkar | 4416907 | 2009-05-28 14:16:04 -0700 | [diff] [blame] | 23 | * Added OMAP4 support - Santosh Shilimkar <santosh.shilimkar@ti.com> |
Tony Lindgren | 1dbae81 | 2005-11-10 14:26:51 +0000 | [diff] [blame] | 24 | * |
| 25 | * This file is subject to the terms and conditions of the GNU General Public |
| 26 | * License. See the file "COPYING" in the main directory of this archive |
| 27 | * for more details. |
| 28 | */ |
| 29 | #include <linux/init.h> |
| 30 | #include <linux/time.h> |
| 31 | #include <linux/interrupt.h> |
| 32 | #include <linux/err.h> |
Russell King | f8ce254 | 2006-01-07 16:15:52 +0000 | [diff] [blame] | 33 | #include <linux/clk.h> |
Timo Teras | 77900a2 | 2006-06-26 16:16:12 -0700 | [diff] [blame] | 34 | #include <linux/delay.h> |
Dirk Behme | e668729 | 2006-12-06 17:14:00 -0800 | [diff] [blame] | 35 | #include <linux/irq.h> |
Kevin Hilman | 5a3a388 | 2007-11-12 23:24:02 -0800 | [diff] [blame] | 36 | #include <linux/clocksource.h> |
| 37 | #include <linux/clockchips.h> |
Tarun Kanti DebBarma | c345c8b | 2011-09-20 17:00:18 +0530 | [diff] [blame] | 38 | #include <linux/slab.h> |
Russell King | f8ce254 | 2006-01-07 16:15:52 +0000 | [diff] [blame] | 39 | |
Tony Lindgren | 1dbae81 | 2005-11-10 14:26:51 +0000 | [diff] [blame] | 40 | #include <asm/mach/time.h> |
Tony Lindgren | ce491cf | 2009-10-20 09:40:47 -0700 | [diff] [blame] | 41 | #include <plat/dmtimer.h> |
Marc Zyngier | a45c983 | 2012-01-10 19:44:19 +0000 | [diff] [blame] | 42 | #include <asm/smp_twd.h> |
Paul Walmsley | cbc9438 | 2011-02-22 19:59:49 -0700 | [diff] [blame] | 43 | #include <asm/sched_clock.h> |
Tony Lindgren | 4e65331 | 2011-11-10 22:45:17 +0100 | [diff] [blame] | 44 | #include "common.h" |
Paul Walmsley | 38698be | 2011-02-23 00:14:08 -0700 | [diff] [blame] | 45 | #include <plat/omap_hwmod.h> |
Tarun Kanti DebBarma | c345c8b | 2011-09-20 17:00:18 +0530 | [diff] [blame] | 46 | #include <plat/omap_device.h> |
Tarun Kanti DebBarma | b481113 | 2011-09-20 17:00:24 +0530 | [diff] [blame] | 47 | #include <plat/omap-pm.h> |
| 48 | |
| 49 | #include "powerdomain.h" |
Tony Lindgren | 1dbae81 | 2005-11-10 14:26:51 +0000 | [diff] [blame] | 50 | |
Tony Lindgren | aa56188 | 2011-03-29 15:54:48 -0700 | [diff] [blame] | 51 | /* Parent clocks, eventually these will come from the clock framework */ |
| 52 | |
| 53 | #define OMAP2_MPU_SOURCE "sys_ck" |
| 54 | #define OMAP3_MPU_SOURCE OMAP2_MPU_SOURCE |
| 55 | #define OMAP4_MPU_SOURCE "sys_clkin_ck" |
| 56 | #define OMAP2_32K_SOURCE "func_32k_ck" |
| 57 | #define OMAP3_32K_SOURCE "omap_32k_fck" |
| 58 | #define OMAP4_32K_SOURCE "sys_32k_ck" |
| 59 | |
| 60 | #ifdef CONFIG_OMAP_32K_TIMER |
| 61 | #define OMAP2_CLKEV_SOURCE OMAP2_32K_SOURCE |
| 62 | #define OMAP3_CLKEV_SOURCE OMAP3_32K_SOURCE |
| 63 | #define OMAP4_CLKEV_SOURCE OMAP4_32K_SOURCE |
| 64 | #define OMAP3_SECURE_TIMER 12 |
| 65 | #else |
| 66 | #define OMAP2_CLKEV_SOURCE OMAP2_MPU_SOURCE |
| 67 | #define OMAP3_CLKEV_SOURCE OMAP3_MPU_SOURCE |
| 68 | #define OMAP4_CLKEV_SOURCE OMAP4_MPU_SOURCE |
| 69 | #define OMAP3_SECURE_TIMER 1 |
| 70 | #endif |
Paul Walmsley | d8328f3 | 2011-01-15 21:32:01 -0700 | [diff] [blame] | 71 | |
Tony Lindgren | aa56188 | 2011-03-29 15:54:48 -0700 | [diff] [blame] | 72 | /* Clockevent code */ |
| 73 | |
| 74 | static struct omap_dm_timer clkev; |
Kevin Hilman | 5a3a388 | 2007-11-12 23:24:02 -0800 | [diff] [blame] | 75 | static struct clock_event_device clockevent_gpt; |
Tony Lindgren | 1dbae81 | 2005-11-10 14:26:51 +0000 | [diff] [blame] | 76 | |
Linus Torvalds | 0cd61b6 | 2006-10-06 10:53:39 -0700 | [diff] [blame] | 77 | static irqreturn_t omap2_gp_timer_interrupt(int irq, void *dev_id) |
Tony Lindgren | 1dbae81 | 2005-11-10 14:26:51 +0000 | [diff] [blame] | 78 | { |
Kevin Hilman | 5a3a388 | 2007-11-12 23:24:02 -0800 | [diff] [blame] | 79 | struct clock_event_device *evt = &clockevent_gpt; |
Tony Lindgren | 1dbae81 | 2005-11-10 14:26:51 +0000 | [diff] [blame] | 80 | |
Tony Lindgren | ee17f11 | 2011-09-16 15:44:20 -0700 | [diff] [blame] | 81 | __omap_dm_timer_write_status(&clkev, OMAP_TIMER_INT_OVERFLOW); |
Kevin Hilman | 5a3a388 | 2007-11-12 23:24:02 -0800 | [diff] [blame] | 82 | |
| 83 | evt->event_handler(evt); |
Tony Lindgren | 1dbae81 | 2005-11-10 14:26:51 +0000 | [diff] [blame] | 84 | return IRQ_HANDLED; |
| 85 | } |
| 86 | |
| 87 | static struct irqaction omap2_gp_timer_irq = { |
Vaibhav Hiremath | f36921b | 2012-05-09 10:07:05 -0700 | [diff] [blame] | 88 | .name = "gp_timer", |
Bernhard Walle | b30faba | 2007-05-08 00:35:39 -0700 | [diff] [blame] | 89 | .flags = IRQF_DISABLED | IRQF_TIMER | IRQF_IRQPOLL, |
Tony Lindgren | 1dbae81 | 2005-11-10 14:26:51 +0000 | [diff] [blame] | 90 | .handler = omap2_gp_timer_interrupt, |
| 91 | }; |
| 92 | |
Kevin Hilman | 5a3a388 | 2007-11-12 23:24:02 -0800 | [diff] [blame] | 93 | static int omap2_gp_timer_set_next_event(unsigned long cycles, |
| 94 | struct clock_event_device *evt) |
Tony Lindgren | 1dbae81 | 2005-11-10 14:26:51 +0000 | [diff] [blame] | 95 | { |
Tony Lindgren | ee17f11 | 2011-09-16 15:44:20 -0700 | [diff] [blame] | 96 | __omap_dm_timer_load_start(&clkev, OMAP_TIMER_CTRL_ST, |
Tony Lindgren | aa56188 | 2011-03-29 15:54:48 -0700 | [diff] [blame] | 97 | 0xffffffff - cycles, 1); |
Tony Lindgren | 1dbae81 | 2005-11-10 14:26:51 +0000 | [diff] [blame] | 98 | |
Kevin Hilman | 5a3a388 | 2007-11-12 23:24:02 -0800 | [diff] [blame] | 99 | return 0; |
| 100 | } |
| 101 | |
| 102 | static void omap2_gp_timer_set_mode(enum clock_event_mode mode, |
| 103 | struct clock_event_device *evt) |
| 104 | { |
| 105 | u32 period; |
| 106 | |
Tony Lindgren | ee17f11 | 2011-09-16 15:44:20 -0700 | [diff] [blame] | 107 | __omap_dm_timer_stop(&clkev, 1, clkev.rate); |
Kevin Hilman | 5a3a388 | 2007-11-12 23:24:02 -0800 | [diff] [blame] | 108 | |
| 109 | switch (mode) { |
| 110 | case CLOCK_EVT_MODE_PERIODIC: |
Tony Lindgren | aa56188 | 2011-03-29 15:54:48 -0700 | [diff] [blame] | 111 | period = clkev.rate / HZ; |
Kevin Hilman | 5a3a388 | 2007-11-12 23:24:02 -0800 | [diff] [blame] | 112 | period -= 1; |
Tony Lindgren | aa56188 | 2011-03-29 15:54:48 -0700 | [diff] [blame] | 113 | /* Looks like we need to first set the load value separately */ |
Tony Lindgren | ee17f11 | 2011-09-16 15:44:20 -0700 | [diff] [blame] | 114 | __omap_dm_timer_write(&clkev, OMAP_TIMER_LOAD_REG, |
Tony Lindgren | aa56188 | 2011-03-29 15:54:48 -0700 | [diff] [blame] | 115 | 0xffffffff - period, 1); |
Tony Lindgren | ee17f11 | 2011-09-16 15:44:20 -0700 | [diff] [blame] | 116 | __omap_dm_timer_load_start(&clkev, |
Tony Lindgren | aa56188 | 2011-03-29 15:54:48 -0700 | [diff] [blame] | 117 | OMAP_TIMER_CTRL_AR | OMAP_TIMER_CTRL_ST, |
| 118 | 0xffffffff - period, 1); |
Kevin Hilman | 5a3a388 | 2007-11-12 23:24:02 -0800 | [diff] [blame] | 119 | break; |
| 120 | case CLOCK_EVT_MODE_ONESHOT: |
| 121 | break; |
| 122 | case CLOCK_EVT_MODE_UNUSED: |
| 123 | case CLOCK_EVT_MODE_SHUTDOWN: |
| 124 | case CLOCK_EVT_MODE_RESUME: |
| 125 | break; |
| 126 | } |
| 127 | } |
| 128 | |
| 129 | static struct clock_event_device clockevent_gpt = { |
Vaibhav Hiremath | f36921b | 2012-05-09 10:07:05 -0700 | [diff] [blame] | 130 | .name = "gp_timer", |
Kevin Hilman | 5a3a388 | 2007-11-12 23:24:02 -0800 | [diff] [blame] | 131 | .features = CLOCK_EVT_FEAT_PERIODIC | CLOCK_EVT_FEAT_ONESHOT, |
| 132 | .shift = 32, |
Santosh Shilimkar | 11d6ec2 | 2012-03-17 15:00:16 +0530 | [diff] [blame] | 133 | .rating = 300, |
Kevin Hilman | 5a3a388 | 2007-11-12 23:24:02 -0800 | [diff] [blame] | 134 | .set_next_event = omap2_gp_timer_set_next_event, |
| 135 | .set_mode = omap2_gp_timer_set_mode, |
| 136 | }; |
| 137 | |
Tony Lindgren | aa56188 | 2011-03-29 15:54:48 -0700 | [diff] [blame] | 138 | static int __init omap_dm_timer_init_one(struct omap_dm_timer *timer, |
| 139 | int gptimer_id, |
| 140 | const char *fck_source) |
Kevin Hilman | 5a3a388 | 2007-11-12 23:24:02 -0800 | [diff] [blame] | 141 | { |
Tony Lindgren | aa56188 | 2011-03-29 15:54:48 -0700 | [diff] [blame] | 142 | char name[10]; /* 10 = sizeof("gptXX_Xck0") */ |
| 143 | struct omap_hwmod *oh; |
Paul Walmsley | 6c0c27f | 2012-04-19 04:01:50 -0600 | [diff] [blame] | 144 | struct resource irq_rsrc, mem_rsrc; |
Tony Lindgren | aa56188 | 2011-03-29 15:54:48 -0700 | [diff] [blame] | 145 | size_t size; |
| 146 | int res = 0; |
Paul Walmsley | 6c0c27f | 2012-04-19 04:01:50 -0600 | [diff] [blame] | 147 | int r; |
Kevin Hilman | 5a3a388 | 2007-11-12 23:24:02 -0800 | [diff] [blame] | 148 | |
Tony Lindgren | aa56188 | 2011-03-29 15:54:48 -0700 | [diff] [blame] | 149 | sprintf(name, "timer%d", gptimer_id); |
| 150 | omap_hwmod_setup_one(name); |
| 151 | oh = omap_hwmod_lookup(name); |
| 152 | if (!oh) |
| 153 | return -ENODEV; |
Paul Walmsley | f248076 | 2009-04-23 21:11:10 -0600 | [diff] [blame] | 154 | |
Paul Walmsley | 6c0c27f | 2012-04-19 04:01:50 -0600 | [diff] [blame] | 155 | r = omap_hwmod_get_resource_byname(oh, IORESOURCE_IRQ, NULL, &irq_rsrc); |
| 156 | if (r) |
| 157 | return -ENXIO; |
| 158 | timer->irq = irq_rsrc.start; |
| 159 | |
| 160 | r = omap_hwmod_get_resource_byname(oh, IORESOURCE_MEM, NULL, &mem_rsrc); |
| 161 | if (r) |
| 162 | return -ENXIO; |
| 163 | timer->phys_base = mem_rsrc.start; |
| 164 | size = mem_rsrc.end - mem_rsrc.start; |
Tony Lindgren | aa56188 | 2011-03-29 15:54:48 -0700 | [diff] [blame] | 165 | |
| 166 | /* Static mapping, never released */ |
| 167 | timer->io_base = ioremap(timer->phys_base, size); |
| 168 | if (!timer->io_base) |
| 169 | return -ENXIO; |
| 170 | |
| 171 | /* After the dmtimer is using hwmod these clocks won't be needed */ |
Tarun Kanti DebBarma | ae6df41 | 2012-07-05 18:10:59 +0530 | [diff] [blame] | 172 | timer->fclk = clk_get(NULL, omap_hwmod_get_main_clk(oh)); |
Tony Lindgren | aa56188 | 2011-03-29 15:54:48 -0700 | [diff] [blame] | 173 | if (IS_ERR(timer->fclk)) |
| 174 | return -ENODEV; |
| 175 | |
Tony Lindgren | aa56188 | 2011-03-29 15:54:48 -0700 | [diff] [blame] | 176 | omap_hwmod_enable(oh); |
| 177 | |
Jon Hunter | b7b4ff7 | 2012-06-05 12:34:51 -0500 | [diff] [blame] | 178 | if (omap_dm_timer_reserve_systimer(gptimer_id)) |
| 179 | return -ENODEV; |
Tony Lindgren | 11a0186 | 2011-03-29 15:54:49 -0700 | [diff] [blame] | 180 | |
Tony Lindgren | aa56188 | 2011-03-29 15:54:48 -0700 | [diff] [blame] | 181 | if (gptimer_id != 12) { |
| 182 | struct clk *src; |
| 183 | |
| 184 | src = clk_get(NULL, fck_source); |
| 185 | if (IS_ERR(src)) { |
| 186 | res = -EINVAL; |
| 187 | } else { |
| 188 | res = __omap_dm_timer_set_source(timer->fclk, src); |
| 189 | if (IS_ERR_VALUE(res)) |
| 190 | pr_warning("%s: timer%i cannot set source\n", |
| 191 | __func__, gptimer_id); |
| 192 | clk_put(src); |
| 193 | } |
| 194 | } |
Tony Lindgren | ee17f11 | 2011-09-16 15:44:20 -0700 | [diff] [blame] | 195 | __omap_dm_timer_init_regs(timer); |
| 196 | __omap_dm_timer_reset(timer, 1, 1); |
Tony Lindgren | aa56188 | 2011-03-29 15:54:48 -0700 | [diff] [blame] | 197 | timer->posted = 1; |
| 198 | |
| 199 | timer->rate = clk_get_rate(timer->fclk); |
| 200 | |
| 201 | timer->reserved = 1; |
Paul Walmsley | 38698be | 2011-02-23 00:14:08 -0700 | [diff] [blame] | 202 | |
Tony Lindgren | aa56188 | 2011-03-29 15:54:48 -0700 | [diff] [blame] | 203 | return res; |
| 204 | } |
Paul Walmsley | f248076 | 2009-04-23 21:11:10 -0600 | [diff] [blame] | 205 | |
Tony Lindgren | aa56188 | 2011-03-29 15:54:48 -0700 | [diff] [blame] | 206 | static void __init omap2_gp_clockevent_init(int gptimer_id, |
| 207 | const char *fck_source) |
| 208 | { |
| 209 | int res; |
Paul Walmsley | f248076 | 2009-04-23 21:11:10 -0600 | [diff] [blame] | 210 | |
Tony Lindgren | aa56188 | 2011-03-29 15:54:48 -0700 | [diff] [blame] | 211 | res = omap_dm_timer_init_one(&clkev, gptimer_id, fck_source); |
| 212 | BUG_ON(res); |
Paul Walmsley | f248076 | 2009-04-23 21:11:10 -0600 | [diff] [blame] | 213 | |
Tony Lindgren | 98e182a | 2011-03-29 15:54:49 -0700 | [diff] [blame] | 214 | omap2_gp_timer_irq.dev_id = (void *)&clkev; |
Tony Lindgren | aa56188 | 2011-03-29 15:54:48 -0700 | [diff] [blame] | 215 | setup_irq(clkev.irq, &omap2_gp_timer_irq); |
Kevin Hilman | 5a3a388 | 2007-11-12 23:24:02 -0800 | [diff] [blame] | 216 | |
Tony Lindgren | ee17f11 | 2011-09-16 15:44:20 -0700 | [diff] [blame] | 217 | __omap_dm_timer_int_enable(&clkev, OMAP_TIMER_INT_OVERFLOW); |
Tony Lindgren | aa56188 | 2011-03-29 15:54:48 -0700 | [diff] [blame] | 218 | |
| 219 | clockevent_gpt.mult = div_sc(clkev.rate, NSEC_PER_SEC, |
Kevin Hilman | 5a3a388 | 2007-11-12 23:24:02 -0800 | [diff] [blame] | 220 | clockevent_gpt.shift); |
| 221 | clockevent_gpt.max_delta_ns = |
| 222 | clockevent_delta2ns(0xffffffff, &clockevent_gpt); |
| 223 | clockevent_gpt.min_delta_ns = |
Aaro Koskinen | df88acb | 2009-01-29 08:57:17 -0800 | [diff] [blame] | 224 | clockevent_delta2ns(3, &clockevent_gpt); |
| 225 | /* Timer internal resynch latency. */ |
Kevin Hilman | 5a3a388 | 2007-11-12 23:24:02 -0800 | [diff] [blame] | 226 | |
Santosh Shilimkar | 11d6ec2 | 2012-03-17 15:00:16 +0530 | [diff] [blame] | 227 | clockevent_gpt.cpumask = cpu_possible_mask; |
| 228 | clockevent_gpt.irq = omap_dm_timer_get_irq(&clkev); |
Kevin Hilman | 5a3a388 | 2007-11-12 23:24:02 -0800 | [diff] [blame] | 229 | clockevents_register_device(&clockevent_gpt); |
Tony Lindgren | aa56188 | 2011-03-29 15:54:48 -0700 | [diff] [blame] | 230 | |
| 231 | pr_info("OMAP clockevent source: GPTIMER%d at %lu Hz\n", |
| 232 | gptimer_id, clkev.rate); |
Kevin Hilman | 5a3a388 | 2007-11-12 23:24:02 -0800 | [diff] [blame] | 233 | } |
| 234 | |
Paul Walmsley | f248076 | 2009-04-23 21:11:10 -0600 | [diff] [blame] | 235 | /* Clocksource code */ |
Tony Lindgren | 3d05a3e | 2011-03-29 15:54:49 -0700 | [diff] [blame] | 236 | static struct omap_dm_timer clksrc; |
Vaibhav Hiremath | 1fe97c8 | 2012-05-09 10:07:05 -0700 | [diff] [blame] | 237 | static bool use_gptimer_clksrc; |
Tony Lindgren | 3d05a3e | 2011-03-29 15:54:49 -0700 | [diff] [blame] | 238 | |
Kevin Hilman | 5a3a388 | 2007-11-12 23:24:02 -0800 | [diff] [blame] | 239 | /* |
| 240 | * clocksource |
| 241 | */ |
Magnus Damm | 8e19608 | 2009-04-21 12:24:00 -0700 | [diff] [blame] | 242 | static cycle_t clocksource_read_cycles(struct clocksource *cs) |
Kevin Hilman | 5a3a388 | 2007-11-12 23:24:02 -0800 | [diff] [blame] | 243 | { |
Tony Lindgren | ee17f11 | 2011-09-16 15:44:20 -0700 | [diff] [blame] | 244 | return (cycle_t)__omap_dm_timer_read_counter(&clksrc, 1); |
Kevin Hilman | 5a3a388 | 2007-11-12 23:24:02 -0800 | [diff] [blame] | 245 | } |
| 246 | |
| 247 | static struct clocksource clocksource_gpt = { |
Vaibhav Hiremath | f36921b | 2012-05-09 10:07:05 -0700 | [diff] [blame] | 248 | .name = "gp_timer", |
Kevin Hilman | 5a3a388 | 2007-11-12 23:24:02 -0800 | [diff] [blame] | 249 | .rating = 300, |
| 250 | .read = clocksource_read_cycles, |
| 251 | .mask = CLOCKSOURCE_MASK(32), |
Kevin Hilman | 5a3a388 | 2007-11-12 23:24:02 -0800 | [diff] [blame] | 252 | .flags = CLOCK_SOURCE_IS_CONTINUOUS, |
| 253 | }; |
| 254 | |
Marc Zyngier | 2f0778af | 2011-12-15 12:19:23 +0100 | [diff] [blame] | 255 | static u32 notrace dmtimer_read_sched_clock(void) |
Paul Walmsley | cbc9438 | 2011-02-22 19:59:49 -0700 | [diff] [blame] | 256 | { |
Tony Lindgren | 3d05a3e | 2011-03-29 15:54:49 -0700 | [diff] [blame] | 257 | if (clksrc.reserved) |
Vaibhav Hiremath | dbc3982 | 2012-01-23 12:18:14 +0530 | [diff] [blame] | 258 | return __omap_dm_timer_read_counter(&clksrc, 1); |
Kevin Hilman | 5a3a388 | 2007-11-12 23:24:02 -0800 | [diff] [blame] | 259 | |
Marc Zyngier | 2f0778af | 2011-12-15 12:19:23 +0100 | [diff] [blame] | 260 | return 0; |
Tony Lindgren | 3d05a3e | 2011-03-29 15:54:49 -0700 | [diff] [blame] | 261 | } |
Kevin Hilman | 5a3a388 | 2007-11-12 23:24:02 -0800 | [diff] [blame] | 262 | |
Igor Grinberg | 45caae7 | 2012-08-28 01:26:14 +0300 | [diff] [blame] | 263 | #ifdef CONFIG_OMAP_32K_TIMER |
Tony Lindgren | 3d05a3e | 2011-03-29 15:54:49 -0700 | [diff] [blame] | 264 | /* Setup free-running counter for clocksource */ |
Vaibhav Hiremath | 1fe97c8 | 2012-05-09 10:07:05 -0700 | [diff] [blame] | 265 | static int __init omap2_sync32k_clocksource_init(void) |
| 266 | { |
| 267 | int ret; |
| 268 | struct omap_hwmod *oh; |
| 269 | void __iomem *vbase; |
| 270 | const char *oh_name = "counter_32k"; |
| 271 | |
| 272 | /* |
| 273 | * First check hwmod data is available for sync32k counter |
| 274 | */ |
| 275 | oh = omap_hwmod_lookup(oh_name); |
| 276 | if (!oh || oh->slaves_cnt == 0) |
| 277 | return -ENODEV; |
| 278 | |
| 279 | omap_hwmod_setup_one(oh_name); |
| 280 | |
| 281 | vbase = omap_hwmod_get_mpu_rt_va(oh); |
| 282 | if (!vbase) { |
| 283 | pr_warn("%s: failed to get counter_32k resource\n", __func__); |
| 284 | return -ENXIO; |
| 285 | } |
| 286 | |
| 287 | ret = omap_hwmod_enable(oh); |
| 288 | if (ret) { |
| 289 | pr_warn("%s: failed to enable counter_32k module (%d)\n", |
| 290 | __func__, ret); |
| 291 | return ret; |
| 292 | } |
| 293 | |
| 294 | ret = omap_init_clocksource_32k(vbase); |
| 295 | if (ret) { |
| 296 | pr_warn("%s: failed to initialize counter_32k as a clocksource (%d)\n", |
| 297 | __func__, ret); |
| 298 | omap_hwmod_idle(oh); |
| 299 | } |
| 300 | |
| 301 | return ret; |
| 302 | } |
Igor Grinberg | 45caae7 | 2012-08-28 01:26:14 +0300 | [diff] [blame] | 303 | #else |
| 304 | static inline int omap2_sync32k_clocksource_init(void) |
| 305 | { |
| 306 | return -ENODEV; |
| 307 | } |
| 308 | #endif |
Vaibhav Hiremath | 1fe97c8 | 2012-05-09 10:07:05 -0700 | [diff] [blame] | 309 | |
| 310 | static void __init omap2_gptimer_clocksource_init(int gptimer_id, |
Tony Lindgren | 3d05a3e | 2011-03-29 15:54:49 -0700 | [diff] [blame] | 311 | const char *fck_source) |
| 312 | { |
| 313 | int res; |
Kevin Hilman | 5a3a388 | 2007-11-12 23:24:02 -0800 | [diff] [blame] | 314 | |
Tony Lindgren | 3d05a3e | 2011-03-29 15:54:49 -0700 | [diff] [blame] | 315 | res = omap_dm_timer_init_one(&clksrc, gptimer_id, fck_source); |
| 316 | BUG_ON(res); |
Paul Walmsley | cbc9438 | 2011-02-22 19:59:49 -0700 | [diff] [blame] | 317 | |
Tony Lindgren | ee17f11 | 2011-09-16 15:44:20 -0700 | [diff] [blame] | 318 | __omap_dm_timer_load_start(&clksrc, |
Hemant Pedanekar | e9d0b97 | 2011-08-10 13:19:35 +0000 | [diff] [blame] | 319 | OMAP_TIMER_CTRL_ST | OMAP_TIMER_CTRL_AR, 0, 1); |
Marc Zyngier | 2f0778af | 2011-12-15 12:19:23 +0100 | [diff] [blame] | 320 | setup_sched_clock(dmtimer_read_sched_clock, 32, clksrc.rate); |
Tony Lindgren | 3d05a3e | 2011-03-29 15:54:49 -0700 | [diff] [blame] | 321 | |
| 322 | if (clocksource_register_hz(&clocksource_gpt, clksrc.rate)) |
| 323 | pr_err("Could not register clocksource %s\n", |
| 324 | clocksource_gpt.name); |
Vaibhav Hiremath | 1fe97c8 | 2012-05-09 10:07:05 -0700 | [diff] [blame] | 325 | else |
| 326 | pr_info("OMAP clocksource: GPTIMER%d at %lu Hz\n", |
| 327 | gptimer_id, clksrc.rate); |
Kevin Hilman | 5a3a388 | 2007-11-12 23:24:02 -0800 | [diff] [blame] | 328 | } |
Vaibhav Hiremath | 1fe97c8 | 2012-05-09 10:07:05 -0700 | [diff] [blame] | 329 | |
| 330 | static void __init omap2_clocksource_init(int gptimer_id, |
| 331 | const char *fck_source) |
| 332 | { |
| 333 | /* |
| 334 | * First give preference to kernel parameter configuration |
| 335 | * by user (clocksource="gp_timer"). |
| 336 | * |
| 337 | * In case of missing kernel parameter for clocksource, |
| 338 | * first check for availability for 32k-sync timer, in case |
| 339 | * of failure in finding 32k_counter module or registering |
| 340 | * it as clocksource, execution will fallback to gp-timer. |
| 341 | */ |
| 342 | if (use_gptimer_clksrc == true) |
| 343 | omap2_gptimer_clocksource_init(gptimer_id, fck_source); |
| 344 | else if (omap2_sync32k_clocksource_init()) |
| 345 | /* Fall back to gp-timer code */ |
| 346 | omap2_gptimer_clocksource_init(gptimer_id, fck_source); |
| 347 | } |
Kevin Hilman | 5a3a388 | 2007-11-12 23:24:02 -0800 | [diff] [blame] | 348 | |
Tony Lindgren | 3d05a3e | 2011-03-29 15:54:49 -0700 | [diff] [blame] | 349 | #define OMAP_SYS_TIMER_INIT(name, clkev_nr, clkev_src, \ |
| 350 | clksrc_nr, clksrc_src) \ |
Tony Lindgren | e74984e | 2011-03-29 15:54:48 -0700 | [diff] [blame] | 351 | static void __init omap##name##_timer_init(void) \ |
| 352 | { \ |
Tony Lindgren | aa56188 | 2011-03-29 15:54:48 -0700 | [diff] [blame] | 353 | omap2_gp_clockevent_init((clkev_nr), clkev_src); \ |
Vaibhav Hiremath | 1fe97c8 | 2012-05-09 10:07:05 -0700 | [diff] [blame] | 354 | omap2_clocksource_init((clksrc_nr), clksrc_src); \ |
Tony Lindgren | e74984e | 2011-03-29 15:54:48 -0700 | [diff] [blame] | 355 | } |
| 356 | |
| 357 | #define OMAP_SYS_TIMER(name) \ |
| 358 | struct sys_timer omap##name##_timer = { \ |
| 359 | .init = omap##name##_timer_init, \ |
| 360 | }; |
| 361 | |
| 362 | #ifdef CONFIG_ARCH_OMAP2 |
Tony Lindgren | 3d05a3e | 2011-03-29 15:54:49 -0700 | [diff] [blame] | 363 | OMAP_SYS_TIMER_INIT(2, 1, OMAP2_CLKEV_SOURCE, 2, OMAP2_MPU_SOURCE) |
Tony Lindgren | e74984e | 2011-03-29 15:54:48 -0700 | [diff] [blame] | 364 | OMAP_SYS_TIMER(2) |
| 365 | #endif |
| 366 | |
| 367 | #ifdef CONFIG_ARCH_OMAP3 |
Tony Lindgren | 3d05a3e | 2011-03-29 15:54:49 -0700 | [diff] [blame] | 368 | OMAP_SYS_TIMER_INIT(3, 1, OMAP3_CLKEV_SOURCE, 2, OMAP3_MPU_SOURCE) |
Tony Lindgren | e74984e | 2011-03-29 15:54:48 -0700 | [diff] [blame] | 369 | OMAP_SYS_TIMER(3) |
Tony Lindgren | 3d05a3e | 2011-03-29 15:54:49 -0700 | [diff] [blame] | 370 | OMAP_SYS_TIMER_INIT(3_secure, OMAP3_SECURE_TIMER, OMAP3_CLKEV_SOURCE, |
| 371 | 2, OMAP3_MPU_SOURCE) |
Tony Lindgren | e74984e | 2011-03-29 15:54:48 -0700 | [diff] [blame] | 372 | OMAP_SYS_TIMER(3_secure) |
| 373 | #endif |
| 374 | |
Afzal Mohammed | 08f3098 | 2012-05-11 00:38:49 +0530 | [diff] [blame] | 375 | #ifdef CONFIG_SOC_AM33XX |
| 376 | OMAP_SYS_TIMER_INIT(3_am33xx, 1, OMAP4_MPU_SOURCE, 2, OMAP4_MPU_SOURCE) |
| 377 | OMAP_SYS_TIMER(3_am33xx) |
| 378 | #endif |
| 379 | |
Tony Lindgren | e74984e | 2011-03-29 15:54:48 -0700 | [diff] [blame] | 380 | #ifdef CONFIG_ARCH_OMAP4 |
Marc Zyngier | a45c983 | 2012-01-10 19:44:19 +0000 | [diff] [blame] | 381 | #ifdef CONFIG_LOCAL_TIMERS |
| 382 | static DEFINE_TWD_LOCAL_TIMER(twd_local_timer, |
| 383 | OMAP44XX_LOCAL_TWD_BASE, |
| 384 | OMAP44XX_IRQ_LOCALTIMER); |
| 385 | #endif |
| 386 | |
Tony Lindgren | e74984e | 2011-03-29 15:54:48 -0700 | [diff] [blame] | 387 | static void __init omap4_timer_init(void) |
Kevin Hilman | 5a3a388 | 2007-11-12 23:24:02 -0800 | [diff] [blame] | 388 | { |
Tony Lindgren | aa56188 | 2011-03-29 15:54:48 -0700 | [diff] [blame] | 389 | omap2_gp_clockevent_init(1, OMAP4_CLKEV_SOURCE); |
Vaibhav Hiremath | 1fe97c8 | 2012-05-09 10:07:05 -0700 | [diff] [blame] | 390 | omap2_clocksource_init(2, OMAP4_MPU_SOURCE); |
Marc Zyngier | a45c983 | 2012-01-10 19:44:19 +0000 | [diff] [blame] | 391 | #ifdef CONFIG_LOCAL_TIMERS |
| 392 | /* Local timers are not supprted on OMAP4430 ES1.0 */ |
| 393 | if (omap_rev() != OMAP4430_REV_ES1_0) { |
| 394 | int err; |
| 395 | |
| 396 | err = twd_local_timer_register(&twd_local_timer); |
| 397 | if (err) |
| 398 | pr_err("twd_local_timer_register failed %d\n", err); |
| 399 | } |
| 400 | #endif |
Tony Lindgren | 1dbae81 | 2005-11-10 14:26:51 +0000 | [diff] [blame] | 401 | } |
Tony Lindgren | e74984e | 2011-03-29 15:54:48 -0700 | [diff] [blame] | 402 | OMAP_SYS_TIMER(4) |
| 403 | #endif |
Tarun Kanti DebBarma | c345c8b | 2011-09-20 17:00:18 +0530 | [diff] [blame] | 404 | |
R Sricharan | 37b3280 | 2012-05-02 13:07:12 +0530 | [diff] [blame] | 405 | #ifdef CONFIG_SOC_OMAP5 |
| 406 | OMAP_SYS_TIMER_INIT(5, 1, OMAP4_CLKEV_SOURCE, 2, OMAP4_MPU_SOURCE) |
| 407 | OMAP_SYS_TIMER(5) |
| 408 | #endif |
| 409 | |
Tarun Kanti DebBarma | c345c8b | 2011-09-20 17:00:18 +0530 | [diff] [blame] | 410 | /** |
Tarun Kanti DebBarma | c345c8b | 2011-09-20 17:00:18 +0530 | [diff] [blame] | 411 | * omap_timer_init - build and register timer device with an |
| 412 | * associated timer hwmod |
| 413 | * @oh: timer hwmod pointer to be used to build timer device |
| 414 | * @user: parameter that can be passed from calling hwmod API |
| 415 | * |
| 416 | * Called by omap_hwmod_for_each_by_class to register each of the timer |
| 417 | * devices present in the system. The number of timer devices is known |
| 418 | * by parsing through the hwmod database for a given class name. At the |
| 419 | * end of function call memory is allocated for timer device and it is |
| 420 | * registered to the framework ready to be proved by the driver. |
| 421 | */ |
| 422 | static int __init omap_timer_init(struct omap_hwmod *oh, void *unused) |
| 423 | { |
| 424 | int id; |
| 425 | int ret = 0; |
| 426 | char *name = "omap_timer"; |
| 427 | struct dmtimer_platform_data *pdata; |
Tony Lindgren | c541c15 | 2011-10-04 09:47:06 -0700 | [diff] [blame] | 428 | struct platform_device *pdev; |
Tarun Kanti DebBarma | c345c8b | 2011-09-20 17:00:18 +0530 | [diff] [blame] | 429 | struct omap_timer_capability_dev_attr *timer_dev_attr; |
| 430 | |
| 431 | pr_debug("%s: %s\n", __func__, oh->name); |
| 432 | |
| 433 | /* on secure device, do not register secure timer */ |
| 434 | timer_dev_attr = oh->dev_attr; |
| 435 | if (omap_type() != OMAP2_DEVICE_TYPE_GP && timer_dev_attr) |
| 436 | if (timer_dev_attr->timer_capability == OMAP_TIMER_SECURE) |
| 437 | return ret; |
| 438 | |
| 439 | pdata = kzalloc(sizeof(*pdata), GFP_KERNEL); |
| 440 | if (!pdata) { |
| 441 | pr_err("%s: No memory for [%s]\n", __func__, oh->name); |
| 442 | return -ENOMEM; |
| 443 | } |
| 444 | |
| 445 | /* |
| 446 | * Extract the IDs from name field in hwmod database |
| 447 | * and use the same for constructing ids' for the |
| 448 | * timer devices. In a way, we are avoiding usage of |
| 449 | * static variable witin the function to do the same. |
| 450 | * CAUTION: We have to be careful and make sure the |
| 451 | * name in hwmod database does not change in which case |
| 452 | * we might either make corresponding change here or |
| 453 | * switch back static variable mechanism. |
| 454 | */ |
| 455 | sscanf(oh->name, "timer%2d", &id); |
| 456 | |
Jon Hunter | d1c1691 | 2012-06-05 12:34:52 -0500 | [diff] [blame] | 457 | if (timer_dev_attr) |
| 458 | pdata->timer_capability = timer_dev_attr->timer_capability; |
Tarun Kanti DebBarma | c345c8b | 2011-09-20 17:00:18 +0530 | [diff] [blame] | 459 | |
Tony Lindgren | c541c15 | 2011-10-04 09:47:06 -0700 | [diff] [blame] | 460 | pdev = omap_device_build(name, id, oh, pdata, sizeof(*pdata), |
Benoit Cousson | c16ae1e | 2011-10-04 23:20:41 +0200 | [diff] [blame] | 461 | NULL, 0, 0); |
Tarun Kanti DebBarma | c345c8b | 2011-09-20 17:00:18 +0530 | [diff] [blame] | 462 | |
Tony Lindgren | c541c15 | 2011-10-04 09:47:06 -0700 | [diff] [blame] | 463 | if (IS_ERR(pdev)) { |
Tarun Kanti DebBarma | c345c8b | 2011-09-20 17:00:18 +0530 | [diff] [blame] | 464 | pr_err("%s: Can't build omap_device for %s: %s.\n", |
| 465 | __func__, name, oh->name); |
| 466 | ret = -EINVAL; |
| 467 | } |
| 468 | |
| 469 | kfree(pdata); |
| 470 | |
| 471 | return ret; |
| 472 | } |
Tarun Kanti DebBarma | 3392cdd | 2011-09-20 17:00:20 +0530 | [diff] [blame] | 473 | |
| 474 | /** |
| 475 | * omap2_dm_timer_init - top level regular device initialization |
| 476 | * |
| 477 | * Uses dedicated hwmod api to parse through hwmod database for |
| 478 | * given class name and then build and register the timer device. |
| 479 | */ |
| 480 | static int __init omap2_dm_timer_init(void) |
| 481 | { |
| 482 | int ret; |
| 483 | |
| 484 | ret = omap_hwmod_for_each_by_class("timer", omap_timer_init, NULL); |
| 485 | if (unlikely(ret)) { |
| 486 | pr_err("%s: device registration failed.\n", __func__); |
| 487 | return -EINVAL; |
| 488 | } |
| 489 | |
| 490 | return 0; |
| 491 | } |
| 492 | arch_initcall(omap2_dm_timer_init); |
Vaibhav Hiremath | 1fe97c8 | 2012-05-09 10:07:05 -0700 | [diff] [blame] | 493 | |
| 494 | /** |
| 495 | * omap2_override_clocksource - clocksource override with user configuration |
| 496 | * |
| 497 | * Allows user to override default clocksource, using kernel parameter |
| 498 | * clocksource="gp_timer" (For all OMAP2PLUS architectures) |
| 499 | * |
| 500 | * Note that, here we are using same standard kernel parameter "clocksource=", |
| 501 | * and not introducing any OMAP specific interface. |
| 502 | */ |
| 503 | static int __init omap2_override_clocksource(char *str) |
| 504 | { |
| 505 | if (!str) |
| 506 | return 0; |
| 507 | /* |
| 508 | * For OMAP architecture, we only have two options |
| 509 | * - sync_32k (default) |
| 510 | * - gp_timer (sys_clk based) |
| 511 | */ |
| 512 | if (!strcmp(str, "gp_timer")) |
| 513 | use_gptimer_clksrc = true; |
| 514 | |
| 515 | return 0; |
| 516 | } |
| 517 | early_param("clocksource", omap2_override_clocksource); |