cadence_ttc_timer.c 14 KB
Newer Older
1
/*
2
 * This file contains driver for the Cadence Triple Timer Counter Rev 06
3
 *
4
 *  Copyright (C) 2011-2013 Xilinx
5 6 7 8 9 10 11 12 13 14 15 16 17
 *
 * based on arch/mips/kernel/time.c timer driver
 *
 * This software is licensed under the terms of the GNU General Public
 * License version 2, as published by the Free Software Foundation, and
 * may be copied, distributed, and modified under those terms.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 */

18
#include <linux/clk.h>
19
#include <linux/clk-provider.h>
20 21
#include <linux/interrupt.h>
#include <linux/clockchips.h>
22 23 24
#include <linux/of_address.h>
#include <linux/of_irq.h>
#include <linux/slab.h>
25
#include <linux/sched_clock.h>
26

27 28 29 30 31 32 33 34 35 36 37 38 39 40 41
/*
 * This driver configures the 2 16-bit count-up timers as follows:
 *
 * T1: Timer 1, clocksource for generic timekeeping
 * T2: Timer 2, clockevent source for hrtimers
 * T3: Timer 3, <unused>
 *
 * The input frequency to the timer module for emulation is 2.5MHz which is
 * common to all the timer channels (T1, T2, and T3). With a pre-scaler of 32,
 * the timers are clocked at 78.125KHz (12.8 us resolution).

 * The input frequency to the timer module in silicon is configurable and
 * obtained from device tree. The pre-scaler of 32 is used.
 */

42 43 44 45
/*
 * Timer Register Offset Definitions of Timer 1, Increment base address by 4
 * and use same offsets for Timer 2
 */
46 47 48 49 50 51
#define TTC_CLK_CNTRL_OFFSET		0x00 /* Clock Control Reg, RW */
#define TTC_CNT_CNTRL_OFFSET		0x0C /* Counter Control Reg, RW */
#define TTC_COUNT_VAL_OFFSET		0x18 /* Counter Value Reg, RO */
#define TTC_INTR_VAL_OFFSET		0x24 /* Interval Count Reg, RW */
#define TTC_ISR_OFFSET		0x54 /* Interrupt Status Reg, RO */
#define TTC_IER_OFFSET		0x60 /* Interrupt Enable Reg, RW */
52

53
#define TTC_CNT_CNTRL_DISABLE_MASK	0x1
54

55
#define TTC_CLK_CNTRL_CSRC_MASK		(1 << 5)	/* clock source */
56 57
#define TTC_CLK_CNTRL_PSV_MASK		0x1e
#define TTC_CLK_CNTRL_PSV_SHIFT		1
58

59 60
/*
 * Setup the timers to use pre-scaling, using a fixed value for now that will
61 62 63 64 65 66
 * work across most input frequency, but it may need to be more dynamic
 */
#define PRESCALE_EXPONENT	11	/* 2 ^ PRESCALE_EXPONENT = PRESCALE */
#define PRESCALE		2048	/* The exponent must match this */
#define CLK_CNTRL_PRESCALE	((PRESCALE_EXPONENT - 1) << 1)
#define CLK_CNTRL_PRESCALE_EN	1
67
#define CNT_CNTRL_RESET		(1 << 4)
68

69 70
#define MAX_F_ERR 50

71
/**
72
 * struct ttc_timer - This definition defines local timer structure
73 74
 *
 * @base_addr:	Base address of timer
75
 * @freq:	Timer input clock frequency
76 77 78
 * @clk:	Associated clock source
 * @clk_rate_change_nb	Notifier block for clock rate changes
 */
79
struct ttc_timer {
80
	void __iomem *base_addr;
81
	unsigned long freq;
82 83
	struct clk *clk;
	struct notifier_block clk_rate_change_nb;
84 85
};

86 87
#define to_ttc_timer(x) \
		container_of(x, struct ttc_timer, clk_rate_change_nb)
88

89
struct ttc_timer_clocksource {
90 91
	u32			scale_clk_ctrl_reg_old;
	u32			scale_clk_ctrl_reg_new;
92
	struct ttc_timer	ttc;
93
	struct clocksource	cs;
94 95
};

96 97
#define to_ttc_timer_clksrc(x) \
		container_of(x, struct ttc_timer_clocksource, cs)
98

99 100
struct ttc_timer_clockevent {
	struct ttc_timer		ttc;
101 102 103
	struct clock_event_device	ce;
};

104 105
#define to_ttc_timer_clkevent(x) \
		container_of(x, struct ttc_timer_clockevent, ce)
106

107 108
static void __iomem *ttc_sched_clock_val_reg;

109
/**
110
 * ttc_set_interval - Set the timer interval value
111 112 113 114
 *
 * @timer:	Pointer to the timer instance
 * @cycles:	Timer interval ticks
 **/
115
static void ttc_set_interval(struct ttc_timer *timer,
116 117 118 119 120
					unsigned long cycles)
{
	u32 ctrl_reg;

	/* Disable the counter, set the counter value  and re-enable counter */
121 122 123
	ctrl_reg = __raw_readl(timer->base_addr + TTC_CNT_CNTRL_OFFSET);
	ctrl_reg |= TTC_CNT_CNTRL_DISABLE_MASK;
	__raw_writel(ctrl_reg, timer->base_addr + TTC_CNT_CNTRL_OFFSET);
124

125
	__raw_writel(cycles, timer->base_addr + TTC_INTR_VAL_OFFSET);
126

127 128 129 130
	/*
	 * Reset the counter (0x10) so that it starts from 0, one-shot
	 * mode makes this needed for timing to be right.
	 */
131
	ctrl_reg |= CNT_CNTRL_RESET;
132 133
	ctrl_reg &= ~TTC_CNT_CNTRL_DISABLE_MASK;
	__raw_writel(ctrl_reg, timer->base_addr + TTC_CNT_CNTRL_OFFSET);
134 135 136
}

/**
137
 * ttc_clock_event_interrupt - Clock event timer interrupt handler
138 139
 *
 * @irq:	IRQ number of the Timer
140
 * @dev_id:	void pointer to the ttc_timer instance
141 142 143
 *
 * returns: Always IRQ_HANDLED - success
 **/
144
static irqreturn_t ttc_clock_event_interrupt(int irq, void *dev_id)
145
{
146 147
	struct ttc_timer_clockevent *ttce = dev_id;
	struct ttc_timer *timer = &ttce->ttc;
148 149

	/* Acknowledge the interrupt and call event handler */
150
	__raw_readl(timer->base_addr + TTC_ISR_OFFSET);
151

152
	ttce->ce.event_handler(&ttce->ce);
153 154 155 156 157

	return IRQ_HANDLED;
}

/**
158
 * __ttc_clocksource_read - Reads the timer counter register
159 160 161
 *
 * returns: Current timer counter register value
 **/
162
static cycle_t __ttc_clocksource_read(struct clocksource *cs)
163
{
164
	struct ttc_timer *timer = &to_ttc_timer_clksrc(cs)->ttc;
165 166

	return (cycle_t)__raw_readl(timer->base_addr +
167
				TTC_COUNT_VAL_OFFSET);
168 169
}

170
static u64 notrace ttc_sched_clock_read(void)
171 172 173 174
{
	return __raw_readl(ttc_sched_clock_val_reg);
}

175
/**
176
 * ttc_set_next_event - Sets the time interval for next event
177 178 179 180 181 182
 *
 * @cycles:	Timer interval ticks
 * @evt:	Address of clock event instance
 *
 * returns: Always 0 - success
 **/
183
static int ttc_set_next_event(unsigned long cycles,
184 185
					struct clock_event_device *evt)
{
186 187
	struct ttc_timer_clockevent *ttce = to_ttc_timer_clkevent(evt);
	struct ttc_timer *timer = &ttce->ttc;
188

189
	ttc_set_interval(timer, cycles);
190 191 192 193
	return 0;
}

/**
194
 * ttc_set_mode - Sets the mode of timer
195 196 197 198
 *
 * @mode:	Mode to be set
 * @evt:	Address of clock event instance
 **/
199
static void ttc_set_mode(enum clock_event_mode mode,
200 201
					struct clock_event_device *evt)
{
202 203
	struct ttc_timer_clockevent *ttce = to_ttc_timer_clkevent(evt);
	struct ttc_timer *timer = &ttce->ttc;
204 205 206 207
	u32 ctrl_reg;

	switch (mode) {
	case CLOCK_EVT_MODE_PERIODIC:
208 209
		ttc_set_interval(timer, DIV_ROUND_CLOSEST(ttce->ttc.freq,
						PRESCALE * HZ));
210 211 212 213 214
		break;
	case CLOCK_EVT_MODE_ONESHOT:
	case CLOCK_EVT_MODE_UNUSED:
	case CLOCK_EVT_MODE_SHUTDOWN:
		ctrl_reg = __raw_readl(timer->base_addr +
215 216
					TTC_CNT_CNTRL_OFFSET);
		ctrl_reg |= TTC_CNT_CNTRL_DISABLE_MASK;
217
		__raw_writel(ctrl_reg,
218
				timer->base_addr + TTC_CNT_CNTRL_OFFSET);
219 220 221
		break;
	case CLOCK_EVT_MODE_RESUME:
		ctrl_reg = __raw_readl(timer->base_addr +
222 223
					TTC_CNT_CNTRL_OFFSET);
		ctrl_reg &= ~TTC_CNT_CNTRL_DISABLE_MASK;
224
		__raw_writel(ctrl_reg,
225
				timer->base_addr + TTC_CNT_CNTRL_OFFSET);
226 227 228 229
		break;
	}
}

230
static int ttc_rate_change_clocksource_cb(struct notifier_block *nb,
231 232 233
		unsigned long event, void *data)
{
	struct clk_notifier_data *ndata = data;
234 235 236
	struct ttc_timer *ttc = to_ttc_timer(nb);
	struct ttc_timer_clocksource *ttccs = container_of(ttc,
			struct ttc_timer_clocksource, ttc);
237 238

	switch (event) {
239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263
	case PRE_RATE_CHANGE:
	{
		u32 psv;
		unsigned long factor, rate_low, rate_high;

		if (ndata->new_rate > ndata->old_rate) {
			factor = DIV_ROUND_CLOSEST(ndata->new_rate,
					ndata->old_rate);
			rate_low = ndata->old_rate;
			rate_high = ndata->new_rate;
		} else {
			factor = DIV_ROUND_CLOSEST(ndata->old_rate,
					ndata->new_rate);
			rate_low = ndata->new_rate;
			rate_high = ndata->old_rate;
		}

		if (!is_power_of_2(factor))
				return NOTIFY_BAD;

		if (abs(rate_high - (factor * rate_low)) > MAX_F_ERR)
			return NOTIFY_BAD;

		factor = __ilog2_u32(factor);

264
		/*
265 266
		 * store timer clock ctrl register so we can restore it in case
		 * of an abort.
267
		 */
268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307
		ttccs->scale_clk_ctrl_reg_old =
			__raw_readl(ttccs->ttc.base_addr +
					TTC_CLK_CNTRL_OFFSET);

		psv = (ttccs->scale_clk_ctrl_reg_old &
				TTC_CLK_CNTRL_PSV_MASK) >>
				TTC_CLK_CNTRL_PSV_SHIFT;
		if (ndata->new_rate < ndata->old_rate)
			psv -= factor;
		else
			psv += factor;

		/* prescaler within legal range? */
		if (psv & ~(TTC_CLK_CNTRL_PSV_MASK >> TTC_CLK_CNTRL_PSV_SHIFT))
			return NOTIFY_BAD;

		ttccs->scale_clk_ctrl_reg_new = ttccs->scale_clk_ctrl_reg_old &
			~TTC_CLK_CNTRL_PSV_MASK;
		ttccs->scale_clk_ctrl_reg_new |= psv << TTC_CLK_CNTRL_PSV_SHIFT;


		/* scale down: adjust divider in post-change notification */
		if (ndata->new_rate < ndata->old_rate)
			return NOTIFY_DONE;

		/* scale up: adjust divider now - before frequency change */
		__raw_writel(ttccs->scale_clk_ctrl_reg_new,
				ttccs->ttc.base_addr + TTC_CLK_CNTRL_OFFSET);
		break;
	}
	case POST_RATE_CHANGE:
		/* scale up: pre-change notification did the adjustment */
		if (ndata->new_rate > ndata->old_rate)
			return NOTIFY_OK;

		/* scale down: adjust divider now - after frequency change */
		__raw_writel(ttccs->scale_clk_ctrl_reg_new,
				ttccs->ttc.base_addr + TTC_CLK_CNTRL_OFFSET);
		break;

308
	case ABORT_RATE_CHANGE:
309 310 311 312 313 314 315 316
		/* we have to undo the adjustment in case we scale up */
		if (ndata->new_rate < ndata->old_rate)
			return NOTIFY_OK;

		/* restore original register value */
		__raw_writel(ttccs->scale_clk_ctrl_reg_old,
				ttccs->ttc.base_addr + TTC_CLK_CNTRL_OFFSET);
		/* fall through */
317 318 319
	default:
		return NOTIFY_DONE;
	}
320 321

	return NOTIFY_DONE;
322 323
}

324
static void __init ttc_setup_clocksource(struct clk *clk, void __iomem *base)
325
{
326
	struct ttc_timer_clocksource *ttccs;
327 328 329 330 331 332
	int err;

	ttccs = kzalloc(sizeof(*ttccs), GFP_KERNEL);
	if (WARN_ON(!ttccs))
		return;

333
	ttccs->ttc.clk = clk;
334

335
	err = clk_prepare_enable(ttccs->ttc.clk);
336 337
	if (WARN_ON(err)) {
		kfree(ttccs);
338
		return;
339
	}
340

341 342
	ttccs->ttc.freq = clk_get_rate(ttccs->ttc.clk);

343 344 345 346 347
	ttccs->ttc.clk_rate_change_nb.notifier_call =
		ttc_rate_change_clocksource_cb;
	ttccs->ttc.clk_rate_change_nb.next = NULL;
	if (clk_notifier_register(ttccs->ttc.clk,
				&ttccs->ttc.clk_rate_change_nb))
348
		pr_warn("Unable to register clock notifier.\n");
349

350 351
	ttccs->ttc.base_addr = base;
	ttccs->cs.name = "ttc_clocksource";
352
	ttccs->cs.rating = 200;
353
	ttccs->cs.read = __ttc_clocksource_read;
354 355 356
	ttccs->cs.mask = CLOCKSOURCE_MASK(16);
	ttccs->cs.flags = CLOCK_SOURCE_IS_CONTINUOUS;

357 358 359 360 361
	/*
	 * Setup the clock source counter to be an incrementing counter
	 * with no interrupt and it rolls over at 0xFFFF. Pre-scale
	 * it by 32 also. Let it start running now.
	 */
362
	__raw_writel(0x0,  ttccs->ttc.base_addr + TTC_IER_OFFSET);
363
	__raw_writel(CLK_CNTRL_PRESCALE | CLK_CNTRL_PRESCALE_EN,
364
		     ttccs->ttc.base_addr + TTC_CLK_CNTRL_OFFSET);
365
	__raw_writel(CNT_CNTRL_RESET,
366
		     ttccs->ttc.base_addr + TTC_CNT_CNTRL_OFFSET);
367

368
	err = clocksource_register_hz(&ttccs->cs, ttccs->ttc.freq / PRESCALE);
369 370
	if (WARN_ON(err)) {
		kfree(ttccs);
371
		return;
372
	}
373 374

	ttc_sched_clock_val_reg = base + TTC_COUNT_VAL_OFFSET;
375
	sched_clock_register(ttc_sched_clock_read, 16, ttccs->ttc.freq / PRESCALE);
376 377
}

378
static int ttc_rate_change_clockevent_cb(struct notifier_block *nb,
379 380 381
		unsigned long event, void *data)
{
	struct clk_notifier_data *ndata = data;
382 383 384
	struct ttc_timer *ttc = to_ttc_timer(nb);
	struct ttc_timer_clockevent *ttcce = container_of(ttc,
			struct ttc_timer_clockevent, ttc);
385 386 387

	switch (event) {
	case POST_RATE_CHANGE:
388 389 390
		/* update cached frequency */
		ttc->freq = ndata->new_rate;

391 392
		clockevents_update_freq(&ttcce->ce, ndata->new_rate / PRESCALE);

393 394 395 396 397 398 399 400
		/* fall through */
	case PRE_RATE_CHANGE:
	case ABORT_RATE_CHANGE:
	default:
		return NOTIFY_DONE;
	}
}

401
static void __init ttc_setup_clockevent(struct clk *clk,
402
						void __iomem *base, u32 irq)
403
{
404
	struct ttc_timer_clockevent *ttcce;
405
	int err;
406 407 408 409 410

	ttcce = kzalloc(sizeof(*ttcce), GFP_KERNEL);
	if (WARN_ON(!ttcce))
		return;

411
	ttcce->ttc.clk = clk;
412

413
	err = clk_prepare_enable(ttcce->ttc.clk);
414 415
	if (WARN_ON(err)) {
		kfree(ttcce);
416
		return;
417
	}
418

419 420 421 422 423
	ttcce->ttc.clk_rate_change_nb.notifier_call =
		ttc_rate_change_clockevent_cb;
	ttcce->ttc.clk_rate_change_nb.next = NULL;
	if (clk_notifier_register(ttcce->ttc.clk,
				&ttcce->ttc.clk_rate_change_nb))
424
		pr_warn("Unable to register clock notifier.\n");
425
	ttcce->ttc.freq = clk_get_rate(ttcce->ttc.clk);
426

427 428
	ttcce->ttc.base_addr = base;
	ttcce->ce.name = "ttc_clockevent";
429
	ttcce->ce.features = CLOCK_EVT_FEAT_PERIODIC | CLOCK_EVT_FEAT_ONESHOT;
430 431
	ttcce->ce.set_next_event = ttc_set_next_event;
	ttcce->ce.set_mode = ttc_set_mode;
432 433
	ttcce->ce.rating = 200;
	ttcce->ce.irq = irq;
434
	ttcce->ce.cpumask = cpu_possible_mask;
435

436 437 438 439 440
	/*
	 * Setup the clock event timer to be an interval timer which
	 * is prescaled by 32 using the interval interrupt. Leave it
	 * disabled for now.
	 */
441
	__raw_writel(0x23, ttcce->ttc.base_addr + TTC_CNT_CNTRL_OFFSET);
442
	__raw_writel(CLK_CNTRL_PRESCALE | CLK_CNTRL_PRESCALE_EN,
443 444
		     ttcce->ttc.base_addr + TTC_CLK_CNTRL_OFFSET);
	__raw_writel(0x1,  ttcce->ttc.base_addr + TTC_IER_OFFSET);
445

446
	err = request_irq(irq, ttc_clock_event_interrupt,
447
			  IRQF_TIMER, ttcce->ce.name, ttcce);
448 449
	if (WARN_ON(err)) {
		kfree(ttcce);
450
		return;
451
	}
452 453

	clockevents_config_and_register(&ttcce->ce,
454
			ttcce->ttc.freq / PRESCALE, 1, 0xfffe);
455 456
}

457
/**
458
 * ttc_timer_init - Initialize the timer
459 460 461
 *
 * Initializes the timer hardware and register the clock source and clock event
 * timers with Linux kernal timer framework
462
 */
463
static void __init ttc_timer_init(struct device_node *timer)
464 465 466
{
	unsigned int irq;
	void __iomem *timer_baseaddr;
467
	struct clk *clk_cs, *clk_ce;
468
	static int initialized;
469
	int clksel;
470 471 472 473 474

	if (initialized)
		return;

	initialized = 1;
475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492

	/*
	 * Get the 1st Triple Timer Counter (TTC) block from the device tree
	 * and use it. Note that the event timer uses the interrupt and it's the
	 * 2nd TTC hence the irq_of_parse_and_map(,1)
	 */
	timer_baseaddr = of_iomap(timer, 0);
	if (!timer_baseaddr) {
		pr_err("ERROR: invalid timer base address\n");
		BUG();
	}

	irq = irq_of_parse_and_map(timer, 1);
	if (irq <= 0) {
		pr_err("ERROR: invalid interrupt number\n");
		BUG();
	}

493 494 495 496 497 498 499 500 501 502 503 504
	clksel = __raw_readl(timer_baseaddr + TTC_CLK_CNTRL_OFFSET);
	clksel = !!(clksel & TTC_CLK_CNTRL_CSRC_MASK);
	clk_cs = of_clk_get(timer, clksel);
	if (IS_ERR(clk_cs)) {
		pr_err("ERROR: timer input clock not found\n");
		BUG();
	}

	clksel = __raw_readl(timer_baseaddr + 4 + TTC_CLK_CNTRL_OFFSET);
	clksel = !!(clksel & TTC_CLK_CNTRL_CSRC_MASK);
	clk_ce = of_clk_get(timer, clksel);
	if (IS_ERR(clk_ce)) {
505 506 507 508
		pr_err("ERROR: timer input clock not found\n");
		BUG();
	}

509 510
	ttc_setup_clocksource(clk_cs, timer_baseaddr);
	ttc_setup_clockevent(clk_ce, timer_baseaddr + 4, irq);
511 512 513 514

	pr_info("%s #0 at %p, irq=%d\n", timer->name, timer_baseaddr, irq);
}

515
CLOCKSOURCE_OF_DECLARE(ttc, "cdns,ttc", ttc_timer_init);