Blame view
drivers/clocksource/timer-davinci.c
9.6 KB
721154f97 clocksource/drive... |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
// SPDX-License-Identifier: GPL-2.0-only /* * TI DaVinci clocksource driver * * Copyright (C) 2019 Texas Instruments * Author: Bartosz Golaszewski <bgolaszewski@baylibre.com> * (with tiny parts adopted from code by Kevin Hilman <khilman@baylibre.com>) */ #include <linux/clk.h> #include <linux/clockchips.h> #include <linux/interrupt.h> #include <linux/kernel.h> #include <linux/of_address.h> #include <linux/of_irq.h> #include <linux/sched_clock.h> #include <clocksource/timer-davinci.h> #undef pr_fmt |
bdf8783c0 clocksource/drive... |
21 |
#define pr_fmt(fmt) "%s: " fmt, __func__ |
721154f97 clocksource/drive... |
22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 |
#define DAVINCI_TIMER_REG_TIM12 0x10 #define DAVINCI_TIMER_REG_TIM34 0x14 #define DAVINCI_TIMER_REG_PRD12 0x18 #define DAVINCI_TIMER_REG_PRD34 0x1c #define DAVINCI_TIMER_REG_TCR 0x20 #define DAVINCI_TIMER_REG_TGCR 0x24 #define DAVINCI_TIMER_TIMMODE_MASK GENMASK(3, 2) #define DAVINCI_TIMER_RESET_MASK GENMASK(1, 0) #define DAVINCI_TIMER_TIMMODE_32BIT_UNCHAINED BIT(2) #define DAVINCI_TIMER_UNRESET GENMASK(1, 0) #define DAVINCI_TIMER_ENAMODE_MASK GENMASK(1, 0) #define DAVINCI_TIMER_ENAMODE_DISABLED 0x00 #define DAVINCI_TIMER_ENAMODE_ONESHOT BIT(0) #define DAVINCI_TIMER_ENAMODE_PERIODIC BIT(1) #define DAVINCI_TIMER_ENAMODE_SHIFT_TIM12 6 #define DAVINCI_TIMER_ENAMODE_SHIFT_TIM34 22 #define DAVINCI_TIMER_MIN_DELTA 0x01 #define DAVINCI_TIMER_MAX_DELTA 0xfffffffe |
b0c74b96d clocksource/drive... |
45 |
#define DAVINCI_TIMER_CLKSRC_BITS 32 |
721154f97 clocksource/drive... |
46 47 48 49 50 51 52 53 |
#define DAVINCI_TIMER_TGCR_DEFAULT \ (DAVINCI_TIMER_TIMMODE_32BIT_UNCHAINED | DAVINCI_TIMER_UNRESET) struct davinci_clockevent { struct clock_event_device dev; void __iomem *base; unsigned int cmp_off; }; |
b0c74b96d clocksource/drive... |
54 55 56 57 58 59 60 61 62 |
/* * This must be globally accessible by davinci_timer_read_sched_clock(), so * let's keep it here. */ static struct { struct clocksource dev; void __iomem *base; unsigned int tim_off; } davinci_clocksource; |
721154f97 clocksource/drive... |
63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 |
static struct davinci_clockevent * to_davinci_clockevent(struct clock_event_device *clockevent) { return container_of(clockevent, struct davinci_clockevent, dev); } static unsigned int davinci_clockevent_read(struct davinci_clockevent *clockevent, unsigned int reg) { return readl_relaxed(clockevent->base + reg); } static void davinci_clockevent_write(struct davinci_clockevent *clockevent, unsigned int reg, unsigned int val) { writel_relaxed(val, clockevent->base + reg); } static void davinci_tim12_shutdown(void __iomem *base) { unsigned int tcr; tcr = DAVINCI_TIMER_ENAMODE_DISABLED << DAVINCI_TIMER_ENAMODE_SHIFT_TIM12; /* * This function is only ever called if we're using both timer * halves. In this case TIM34 runs in periodic mode and we must * not modify it. */ tcr |= DAVINCI_TIMER_ENAMODE_PERIODIC << DAVINCI_TIMER_ENAMODE_SHIFT_TIM34; writel_relaxed(tcr, base + DAVINCI_TIMER_REG_TCR); } static void davinci_tim12_set_oneshot(void __iomem *base) { unsigned int tcr; tcr = DAVINCI_TIMER_ENAMODE_ONESHOT << DAVINCI_TIMER_ENAMODE_SHIFT_TIM12; /* Same as above. */ tcr |= DAVINCI_TIMER_ENAMODE_PERIODIC << DAVINCI_TIMER_ENAMODE_SHIFT_TIM34; writel_relaxed(tcr, base + DAVINCI_TIMER_REG_TCR); } static int davinci_clockevent_shutdown(struct clock_event_device *dev) { struct davinci_clockevent *clockevent; clockevent = to_davinci_clockevent(dev); davinci_tim12_shutdown(clockevent->base); return 0; } static int davinci_clockevent_set_oneshot(struct clock_event_device *dev) { struct davinci_clockevent *clockevent = to_davinci_clockevent(dev); davinci_clockevent_write(clockevent, DAVINCI_TIMER_REG_TIM12, 0x0); davinci_tim12_set_oneshot(clockevent->base); return 0; } static int davinci_clockevent_set_next_event_std(unsigned long cycles, struct clock_event_device *dev) { struct davinci_clockevent *clockevent = to_davinci_clockevent(dev); davinci_clockevent_shutdown(dev); davinci_clockevent_write(clockevent, DAVINCI_TIMER_REG_TIM12, 0x0); davinci_clockevent_write(clockevent, DAVINCI_TIMER_REG_PRD12, cycles); davinci_clockevent_set_oneshot(dev); return 0; } static int davinci_clockevent_set_next_event_cmp(unsigned long cycles, struct clock_event_device *dev) { struct davinci_clockevent *clockevent = to_davinci_clockevent(dev); unsigned int curr_time; curr_time = davinci_clockevent_read(clockevent, DAVINCI_TIMER_REG_TIM12); davinci_clockevent_write(clockevent, clockevent->cmp_off, curr_time + cycles); return 0; } static irqreturn_t davinci_timer_irq_timer(int irq, void *data) { struct davinci_clockevent *clockevent = data; if (!clockevent_state_oneshot(&clockevent->dev)) davinci_tim12_shutdown(clockevent->base); clockevent->dev.event_handler(&clockevent->dev); return IRQ_HANDLED; } |
b0c74b96d clocksource/drive... |
176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 |
static u64 notrace davinci_timer_read_sched_clock(void) { return readl_relaxed(davinci_clocksource.base + davinci_clocksource.tim_off); } static u64 davinci_clocksource_read(struct clocksource *dev) { return davinci_timer_read_sched_clock(); } /* * Standard use-case: we're using tim12 for clockevent and tim34 for * clocksource. The default is making the former run in oneshot mode * and the latter in periodic mode. */ static void davinci_clocksource_init_tim34(void __iomem *base) { int tcr; tcr = DAVINCI_TIMER_ENAMODE_PERIODIC << DAVINCI_TIMER_ENAMODE_SHIFT_TIM34; tcr |= DAVINCI_TIMER_ENAMODE_ONESHOT << DAVINCI_TIMER_ENAMODE_SHIFT_TIM12; writel_relaxed(0x0, base + DAVINCI_TIMER_REG_TIM34); writel_relaxed(UINT_MAX, base + DAVINCI_TIMER_REG_PRD34); writel_relaxed(tcr, base + DAVINCI_TIMER_REG_TCR); } /* * Special use-case on da830: the DSP may use tim34. We're using tim12 for * both clocksource and clockevent. We set tim12 to periodic and don't touch * tim34. */ static void davinci_clocksource_init_tim12(void __iomem *base) { unsigned int tcr; tcr = DAVINCI_TIMER_ENAMODE_PERIODIC << DAVINCI_TIMER_ENAMODE_SHIFT_TIM12; writel_relaxed(0x0, base + DAVINCI_TIMER_REG_TIM12); writel_relaxed(UINT_MAX, base + DAVINCI_TIMER_REG_PRD12); writel_relaxed(tcr, base + DAVINCI_TIMER_REG_TCR); } |
721154f97 clocksource/drive... |
222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 |
static void davinci_timer_init(void __iomem *base) { /* Set clock to internal mode and disable it. */ writel_relaxed(0x0, base + DAVINCI_TIMER_REG_TCR); /* * Reset both 32-bit timers, set no prescaler for timer 34, set the * timer to dual 32-bit unchained mode, unreset both 32-bit timers. */ writel_relaxed(DAVINCI_TIMER_TGCR_DEFAULT, base + DAVINCI_TIMER_REG_TGCR); /* Init both counters to zero. */ writel_relaxed(0x0, base + DAVINCI_TIMER_REG_TIM12); writel_relaxed(0x0, base + DAVINCI_TIMER_REG_TIM34); } int __init davinci_timer_register(struct clk *clk, const struct davinci_timer_cfg *timer_cfg) { struct davinci_clockevent *clockevent; unsigned int tick_rate; void __iomem *base; int rv; rv = clk_prepare_enable(clk); if (rv) { |
bdf8783c0 clocksource/drive... |
247 248 |
pr_err("Unable to prepare and enable the timer clock "); |
721154f97 clocksource/drive... |
249 250 251 252 253 254 |
return rv; } if (!request_mem_region(timer_cfg->reg.start, resource_size(&timer_cfg->reg), "davinci-timer")) { |
bdf8783c0 clocksource/drive... |
255 256 |
pr_err("Unable to request memory region "); |
721154f97 clocksource/drive... |
257 258 259 260 261 |
return -EBUSY; } base = ioremap(timer_cfg->reg.start, resource_size(&timer_cfg->reg)); if (!base) { |
bdf8783c0 clocksource/drive... |
262 263 |
pr_err("Unable to map the register range "); |
721154f97 clocksource/drive... |
264 265 266 267 268 |
return -ENOMEM; } davinci_timer_init(base); tick_rate = clk_get_rate(clk); |
4855f2bd9 clocksource: davi... |
269 |
clockevent = kzalloc(sizeof(*clockevent), GFP_KERNEL); |
bdf8783c0 clocksource/drive... |
270 |
if (!clockevent) |
721154f97 clocksource/drive... |
271 |
return -ENOMEM; |
721154f97 clocksource/drive... |
272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 |
clockevent->dev.name = "tim12"; clockevent->dev.features = CLOCK_EVT_FEAT_ONESHOT; clockevent->dev.cpumask = cpumask_of(0); clockevent->base = base; if (timer_cfg->cmp_off) { clockevent->cmp_off = timer_cfg->cmp_off; clockevent->dev.set_next_event = davinci_clockevent_set_next_event_cmp; } else { clockevent->dev.set_next_event = davinci_clockevent_set_next_event_std; clockevent->dev.set_state_oneshot = davinci_clockevent_set_oneshot; clockevent->dev.set_state_shutdown = davinci_clockevent_shutdown; } rv = request_irq(timer_cfg->irq[DAVINCI_TIMER_CLOCKEVENT_IRQ].start, davinci_timer_irq_timer, IRQF_TIMER, "clockevent/tim12", clockevent); if (rv) { |
bdf8783c0 clocksource/drive... |
295 296 |
pr_err("Unable to request the clockevent interrupt "); |
721154f97 clocksource/drive... |
297 298 |
return rv; } |
b0c74b96d clocksource/drive... |
299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 |
davinci_clocksource.dev.rating = 300; davinci_clocksource.dev.read = davinci_clocksource_read; davinci_clocksource.dev.mask = CLOCKSOURCE_MASK(DAVINCI_TIMER_CLKSRC_BITS); davinci_clocksource.dev.flags = CLOCK_SOURCE_IS_CONTINUOUS; davinci_clocksource.base = base; if (timer_cfg->cmp_off) { davinci_clocksource.dev.name = "tim12"; davinci_clocksource.tim_off = DAVINCI_TIMER_REG_TIM12; davinci_clocksource_init_tim12(base); } else { davinci_clocksource.dev.name = "tim34"; davinci_clocksource.tim_off = DAVINCI_TIMER_REG_TIM34; davinci_clocksource_init_tim34(base); } |
cea931c25 clocksource: davi... |
315 316 317 |
clockevents_config_and_register(&clockevent->dev, tick_rate, DAVINCI_TIMER_MIN_DELTA, DAVINCI_TIMER_MAX_DELTA); |
b0c74b96d clocksource/drive... |
318 319 |
rv = clocksource_register_hz(&davinci_clocksource.dev, tick_rate); if (rv) { |
bdf8783c0 clocksource/drive... |
320 321 |
pr_err("Unable to register clocksource "); |
b0c74b96d clocksource/drive... |
322 323 324 325 326 |
return rv; } sched_clock_register(davinci_timer_read_sched_clock, DAVINCI_TIMER_CLKSRC_BITS, tick_rate); |
721154f97 clocksource/drive... |
327 328 329 330 331 332 333 334 335 336 337 |
return 0; } static int __init of_davinci_timer_register(struct device_node *np) { struct davinci_timer_cfg timer_cfg = { }; struct clk *clk; int rv; rv = of_address_to_resource(np, 0, &timer_cfg.reg); if (rv) { |
bdf8783c0 clocksource/drive... |
338 339 |
pr_err("Unable to get the register range for timer "); |
721154f97 clocksource/drive... |
340 341 342 343 344 345 |
return rv; } rv = of_irq_to_resource_table(np, timer_cfg.irq, DAVINCI_TIMER_NUM_IRQS); if (rv != DAVINCI_TIMER_NUM_IRQS) { |
bdf8783c0 clocksource/drive... |
346 347 |
pr_err("Unable to get the interrupts for timer "); |
721154f97 clocksource/drive... |
348 349 350 351 352 |
return rv; } clk = of_clk_get(np, 0); if (IS_ERR(clk)) { |
bdf8783c0 clocksource/drive... |
353 354 |
pr_err("Unable to get the timer clock "); |
721154f97 clocksource/drive... |
355 356 357 358 359 360 361 362 363 364 |
return PTR_ERR(clk); } rv = davinci_timer_register(clk, &timer_cfg); if (rv) clk_put(clk); return rv; } TIMER_OF_DECLARE(davinci_timer, "ti,da830-timer", of_davinci_timer_register); |