time.c 30.1 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
/*
 * Common time routines among all ppc machines.
 *
 * Written by Cort Dougan (cort@cs.nmt.edu) to merge
 * Paul Mackerras' version and mine for PReP and Pmac.
 * MPC8xx/MBX changes by Dan Malek (dmalek@jlc.net).
 * Converted for 64-bit by Mike Corrigan (mikejc@us.ibm.com)
 *
 * First round of bugfixes by Gabriel Paubert (paubert@iram.es)
 * to make clock more stable (2.4.0-test5). The only thing
 * that this code assumes is that the timebases have been synchronized
 * by firmware on SMP and are never stopped (never do sleep
 * on SMP then, nap and doze are OK).
 * 
 * Speeded up do_gettimeofday by getting rid of references to
 * xtime (which required locks for consistency). (mikejc@us.ibm.com)
 *
 * TODO (not necessarily in this file):
 * - improve precision and reproducibility of timebase frequency
 * measurement at boot time. (for iSeries, we calibrate the timebase
 * against the Titan chip's clock.)
 * - for astronomical applications: add a new function to get
 * non ambiguous timestamps even around leap seconds. This needs
 * a new timestamp format and a good name.
 *
 * 1997-09-10  Updated NTP code according to technical memorandum Jan '96
 *             "A Kernel Model for Precision Timekeeping" by Dave Mills
 *
 *      This program is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU General Public License
 *      as published by the Free Software Foundation; either version
 *      2 of the License, or (at your option) any later version.
 */

#include <linux/errno.h>
#include <linux/module.h>
#include <linux/sched.h>
#include <linux/kernel.h>
#include <linux/param.h>
#include <linux/string.h>
#include <linux/mm.h>
#include <linux/interrupt.h>
#include <linux/timex.h>
#include <linux/kernel_stat.h>
#include <linux/time.h>
#include <linux/init.h>
#include <linux/profile.h>
#include <linux/cpu.h>
#include <linux/security.h>
50
51
#include <linux/percpu.h>
#include <linux/rtc.h>
52
#include <linux/jiffies.h>
53
#include <linux/posix-timers.h>
54
#include <linux/irq.h>
Linus Torvalds's avatar
Linus Torvalds committed
55
56
57
58
59
60
61
62
63

#include <asm/io.h>
#include <asm/processor.h>
#include <asm/nvram.h>
#include <asm/cache.h>
#include <asm/machdep.h>
#include <asm/uaccess.h>
#include <asm/time.h>
#include <asm/prom.h>
64
65
#include <asm/irq.h>
#include <asm/div64.h>
66
#include <asm/smp.h>
67
#include <asm/vdso_datapage.h>
68
#include <asm/firmware.h>
69
#ifdef CONFIG_PPC_ISERIES
70
#include <asm/iseries/it_lp_queue.h>
71
#include <asm/iseries/hv_call_xm.h>
72
#endif
Linus Torvalds's avatar
Linus Torvalds committed
73

74
75
/* powerpc clocksource/clockevent code */

76
#include <linux/clockchips.h>
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
#include <linux/clocksource.h>

static cycle_t rtc_read(void);
static struct clocksource clocksource_rtc = {
	.name         = "rtc",
	.rating       = 400,
	.flags        = CLOCK_SOURCE_IS_CONTINUOUS,
	.mask         = CLOCKSOURCE_MASK(64),
	.shift        = 22,
	.mult         = 0,	/* To be filled in */
	.read         = rtc_read,
};

static cycle_t timebase_read(void);
static struct clocksource clocksource_timebase = {
	.name         = "timebase",
	.rating       = 400,
	.flags        = CLOCK_SOURCE_IS_CONTINUOUS,
	.mask         = CLOCKSOURCE_MASK(64),
	.shift        = 22,
	.mult         = 0,	/* To be filled in */
	.read         = timebase_read,
};

101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
#define DECREMENTER_MAX	0x7fffffff

static int decrementer_set_next_event(unsigned long evt,
				      struct clock_event_device *dev);
static void decrementer_set_mode(enum clock_event_mode mode,
				 struct clock_event_device *dev);

static struct clock_event_device decrementer_clockevent = {
       .name           = "decrementer",
       .rating         = 200,
       .shift          = 32,
       .mult           = 0,	/* To be filled in */
       .irq            = 0,
       .set_next_event = decrementer_set_next_event,
       .set_mode       = decrementer_set_mode,
       .features       = CLOCK_EVT_FEAT_ONESHOT,
};

static DEFINE_PER_CPU(struct clock_event_device, decrementers);
void init_decrementer_clockevent(void);
121
static DEFINE_PER_CPU(u64, decrementer_next_tb);
122

Linus Torvalds's avatar
Linus Torvalds committed
123
#ifdef CONFIG_PPC_ISERIES
124
125
static unsigned long __initdata iSeries_recal_titan;
static signed long __initdata iSeries_recal_tb;
126
127
128

/* Forward declaration is only needed for iSereis compiles */
void __init clocksource_init(void);
Linus Torvalds's avatar
Linus Torvalds committed
129
130
131
132
#endif

#define XSEC_PER_SEC (1024*1024)

133
134
135
136
137
138
139
#ifdef CONFIG_PPC64
#define SCALE_XSEC(xsec, max)	(((xsec) * max) / XSEC_PER_SEC)
#else
/* compute ((xsec << 12) * max) >> 32 */
#define SCALE_XSEC(xsec, max)	mulhwu((xsec) << 12, max)
#endif

Linus Torvalds's avatar
Linus Torvalds committed
140
141
142
143
unsigned long tb_ticks_per_jiffy;
unsigned long tb_ticks_per_usec = 100; /* sane default */
EXPORT_SYMBOL(tb_ticks_per_usec);
unsigned long tb_ticks_per_sec;
144
EXPORT_SYMBOL(tb_ticks_per_sec);	/* for cputime_t conversions */
145
146
u64 tb_to_xs;
unsigned tb_to_us;
147

148
#define TICKLEN_SCALE	TICK_LENGTH_SHIFT
149
150
151
152
153
154
155
u64 last_tick_len;	/* units are ns / 2^TICKLEN_SCALE */
u64 ticklen_to_xs;	/* 0.64 fraction */

/* If last_tick_len corresponds to about 1/HZ seconds, then
   last_tick_len << TICKLEN_SHIFT will be about 2^63. */
#define TICKLEN_SHIFT	(63 - 30 - TICKLEN_SCALE + SHIFT_HZ)

Linus Torvalds's avatar
Linus Torvalds committed
156
DEFINE_SPINLOCK(rtc_lock);
157
EXPORT_SYMBOL_GPL(rtc_lock);
Linus Torvalds's avatar
Linus Torvalds committed
158

159
160
161
static u64 tb_to_ns_scale __read_mostly;
static unsigned tb_to_ns_shift __read_mostly;
static unsigned long boot_tb __read_mostly;
Linus Torvalds's avatar
Linus Torvalds committed
162
163
164
165

struct gettimeofday_struct do_gtod;

extern struct timezone sys_tz;
166
static long timezone_offset;
Linus Torvalds's avatar
Linus Torvalds committed
167

168
unsigned long ppc_proc_freq;
169
EXPORT_SYMBOL(ppc_proc_freq);
170
171
unsigned long ppc_tb_freq;

172
173
static u64 tb_last_jiffy __cacheline_aligned_in_smp;
static DEFINE_PER_CPU(u64, last_jiffy);
174

175
176
177
178
179
180
181
#ifdef CONFIG_VIRT_CPU_ACCOUNTING
/*
 * Factors for converting from cputime_t (timebase ticks) to
 * jiffies, milliseconds, seconds, and clock_t (1/USER_HZ seconds).
 * These are all stored as 0.64 fixed-point binary fractions.
 */
u64 __cputime_jiffies_factor;
182
EXPORT_SYMBOL(__cputime_jiffies_factor);
183
u64 __cputime_msec_factor;
184
EXPORT_SYMBOL(__cputime_msec_factor);
185
u64 __cputime_sec_factor;
186
EXPORT_SYMBOL(__cputime_sec_factor);
187
u64 __cputime_clockt_factor;
188
EXPORT_SYMBOL(__cputime_clockt_factor);
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
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
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270

static void calc_cputime_factors(void)
{
	struct div_result res;

	div128_by_32(HZ, 0, tb_ticks_per_sec, &res);
	__cputime_jiffies_factor = res.result_low;
	div128_by_32(1000, 0, tb_ticks_per_sec, &res);
	__cputime_msec_factor = res.result_low;
	div128_by_32(1, 0, tb_ticks_per_sec, &res);
	__cputime_sec_factor = res.result_low;
	div128_by_32(USER_HZ, 0, tb_ticks_per_sec, &res);
	__cputime_clockt_factor = res.result_low;
}

/*
 * Read the PURR on systems that have it, otherwise the timebase.
 */
static u64 read_purr(void)
{
	if (cpu_has_feature(CPU_FTR_PURR))
		return mfspr(SPRN_PURR);
	return mftb();
}

/*
 * Account time for a transition between system, hard irq
 * or soft irq state.
 */
void account_system_vtime(struct task_struct *tsk)
{
	u64 now, delta;
	unsigned long flags;

	local_irq_save(flags);
	now = read_purr();
	delta = now - get_paca()->startpurr;
	get_paca()->startpurr = now;
	if (!in_interrupt()) {
		delta += get_paca()->system_time;
		get_paca()->system_time = 0;
	}
	account_system_time(tsk, 0, delta);
	local_irq_restore(flags);
}

/*
 * Transfer the user and system times accumulated in the paca
 * by the exception entry and exit code to the generic process
 * user and system time records.
 * Must be called with interrupts disabled.
 */
void account_process_vtime(struct task_struct *tsk)
{
	cputime_t utime;

	utime = get_paca()->user_time;
	get_paca()->user_time = 0;
	account_user_time(tsk, utime);
}

static void account_process_time(struct pt_regs *regs)
{
	int cpu = smp_processor_id();

	account_process_vtime(current);
	run_local_timers();
	if (rcu_pending(cpu))
		rcu_check_callbacks(cpu, user_mode(regs));
	scheduler_tick();
 	run_posix_cpu_timers(current);
}

/*
 * Stuff for accounting stolen time.
 */
struct cpu_purr_data {
	int	initialized;			/* thread is running */
	u64	tb;			/* last TB value read */
	u64	purr;			/* last PURR value read */
};

271
272
273
274
275
276
277
/*
 * Each entry in the cpu_purr_data array is manipulated only by its
 * "owner" cpu -- usually in the timer interrupt but also occasionally
 * in process context for cpu online.  As long as cpus do not touch
 * each others' cpu_purr_data, disabling local interrupts is
 * sufficient to serialize accesses.
 */
278
279
280
281
static DEFINE_PER_CPU(struct cpu_purr_data, cpu_purr_data);

static void snapshot_tb_and_purr(void *data)
{
282
	unsigned long flags;
283
284
	struct cpu_purr_data *p = &__get_cpu_var(cpu_purr_data);

285
	local_irq_save(flags);
286
	p->tb = get_tb_or_rtc();
287
	p->purr = mfspr(SPRN_PURR);
288
289
	wmb();
	p->initialized = 1;
290
	local_irq_restore(flags);
291
292
293
294
295
296
297
298
299
300
301
302
}

/*
 * Called during boot when all cpus have come up.
 */
void snapshot_timebases(void)
{
	if (!cpu_has_feature(CPU_FTR_PURR))
		return;
	on_each_cpu(snapshot_tb_and_purr, NULL, 0, 1);
}

303
304
305
/*
 * Must be called with interrupts disabled.
 */
306
307
void calculate_steal_time(void)
{
308
	u64 tb, purr;
309
	s64 stolen;
310
	struct cpu_purr_data *pme;
311
312
313

	if (!cpu_has_feature(CPU_FTR_PURR))
		return;
314
	pme = &per_cpu(cpu_purr_data, smp_processor_id());
315
316
317
	if (!pme->initialized)
		return;		/* this can happen in early boot */
	tb = mftb();
318
319
320
	purr = mfspr(SPRN_PURR);
	stolen = (tb - pme->tb) - (purr - pme->purr);
	if (stolen > 0)
321
322
323
324
325
		account_steal_time(current, stolen);
	pme->tb = tb;
	pme->purr = purr;
}

326
#ifdef CONFIG_PPC_SPLPAR
327
328
329
330
331
332
/*
 * Must be called before the cpu is added to the online map when
 * a cpu is being brought up at runtime.
 */
static void snapshot_purr(void)
{
333
	struct cpu_purr_data *pme;
334
335
336
337
	unsigned long flags;

	if (!cpu_has_feature(CPU_FTR_PURR))
		return;
338
	local_irq_save(flags);
339
340
341
	pme = &per_cpu(cpu_purr_data, smp_processor_id());
	pme->tb = mftb();
	pme->purr = mfspr(SPRN_PURR);
342
	pme->initialized = 1;
343
	local_irq_restore(flags);
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
}

#endif /* CONFIG_PPC_SPLPAR */

#else /* ! CONFIG_VIRT_CPU_ACCOUNTING */
#define calc_cputime_factors()
#define account_process_time(regs)	update_process_times(user_mode(regs))
#define calculate_steal_time()		do { } while (0)
#endif

#if !(defined(CONFIG_VIRT_CPU_ACCOUNTING) && defined(CONFIG_PPC_SPLPAR))
#define snapshot_purr()			do { } while (0)
#endif

/*
 * Called when a cpu comes up after the system has finished booting,
 * i.e. as a result of a hotplug cpu action.
 */
void snapshot_timebase(void)
{
364
	__get_cpu_var(last_jiffy) = get_tb_or_rtc();
365
366
367
	snapshot_purr();
}

368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
void __delay(unsigned long loops)
{
	unsigned long start;
	int diff;

	if (__USE_RTC()) {
		start = get_rtcl();
		do {
			/* the RTCL register wraps at 1000000000 */
			diff = get_rtcl() - start;
			if (diff < 0)
				diff += 1000000000;
		} while (diff < loops);
	} else {
		start = get_tbl();
		while (get_tbl() - start < loops)
			HMT_low();
		HMT_medium();
	}
}
EXPORT_SYMBOL(__delay);

void udelay(unsigned long usecs)
{
	__delay(tb_ticks_per_usec * usecs);
}
EXPORT_SYMBOL(udelay);

Linus Torvalds's avatar
Linus Torvalds committed
396
397

/*
398
399
400
401
402
403
 * There are two copies of tb_to_xs and stamp_xsec so that no
 * lock is needed to access and use these values in
 * do_gettimeofday.  We alternate the copies and as long as a
 * reasonable time elapses between changes, there will never
 * be inconsistent values.  ntpd has a minimum of one minute
 * between updates.
Linus Torvalds's avatar
Linus Torvalds committed
404
 */
405
static inline void update_gtod(u64 new_tb_stamp, u64 new_stamp_xsec,
406
			       u64 new_tb_to_xs)
Linus Torvalds's avatar
Linus Torvalds committed
407
408
{
	unsigned temp_idx;
409
	struct gettimeofday_vars *temp_varp;
Linus Torvalds's avatar
Linus Torvalds committed
410
411
412
413

	temp_idx = (do_gtod.var_idx == 0);
	temp_varp = &do_gtod.vars[temp_idx];

414
415
	temp_varp->tb_to_xs = new_tb_to_xs;
	temp_varp->tb_orig_stamp = new_tb_stamp;
Linus Torvalds's avatar
Linus Torvalds committed
416
	temp_varp->stamp_xsec = new_stamp_xsec;
417
	smp_mb();
Linus Torvalds's avatar
Linus Torvalds committed
418
419
420
	do_gtod.varp = temp_varp;
	do_gtod.var_idx = temp_idx;

421
422
423
424
425
426
427
428
	/*
	 * tb_update_count is used to allow the userspace gettimeofday code
	 * to assure itself that it sees a consistent view of the tb_to_xs and
	 * stamp_xsec variables.  It reads the tb_update_count, then reads
	 * tb_to_xs and stamp_xsec and then reads tb_update_count again.  If
	 * the two values of tb_update_count match and are even then the
	 * tb_to_xs and stamp_xsec values are consistent.  If not, then it
	 * loops back and reads them again until this criteria is met.
429
430
	 * We expect the caller to have done the first increment of
	 * vdso_data->tb_update_count already.
431
	 */
432
433
434
435
436
	vdso_data->tb_orig_stamp = new_tb_stamp;
	vdso_data->stamp_xsec = new_stamp_xsec;
	vdso_data->tb_to_xs = new_tb_to_xs;
	vdso_data->wtom_clock_sec = wall_to_monotonic.tv_sec;
	vdso_data->wtom_clock_nsec = wall_to_monotonic.tv_nsec;
437
	smp_wmb();
438
	++(vdso_data->tb_update_count);
439
440
}

Linus Torvalds's avatar
Linus Torvalds committed
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
#ifdef CONFIG_SMP
unsigned long profile_pc(struct pt_regs *regs)
{
	unsigned long pc = instruction_pointer(regs);

	if (in_lock_functions(pc))
		return regs->link;

	return pc;
}
EXPORT_SYMBOL(profile_pc);
#endif

#ifdef CONFIG_PPC_ISERIES

/* 
 * This function recalibrates the timebase based on the 49-bit time-of-day
 * value in the Titan chip.  The Titan is much more accurate than the value
 * returned by the service processor for the timebase frequency.  
 */

462
static int __init iSeries_tb_recal(void)
Linus Torvalds's avatar
Linus Torvalds committed
463
464
465
{
	struct div_result divres;
	unsigned long titan, tb;
466
467
468
469
470

	/* Make sure we only run on iSeries */
	if (!firmware_has_feature(FW_FEATURE_ISERIES))
		return -ENODEV;

Linus Torvalds's avatar
Linus Torvalds committed
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
	tb = get_tb();
	titan = HvCallXm_loadTod();
	if ( iSeries_recal_titan ) {
		unsigned long tb_ticks = tb - iSeries_recal_tb;
		unsigned long titan_usec = (titan - iSeries_recal_titan) >> 12;
		unsigned long new_tb_ticks_per_sec   = (tb_ticks * USEC_PER_SEC)/titan_usec;
		unsigned long new_tb_ticks_per_jiffy = (new_tb_ticks_per_sec+(HZ/2))/HZ;
		long tick_diff = new_tb_ticks_per_jiffy - tb_ticks_per_jiffy;
		char sign = '+';		
		/* make sure tb_ticks_per_sec and tb_ticks_per_jiffy are consistent */
		new_tb_ticks_per_sec = new_tb_ticks_per_jiffy * HZ;

		if ( tick_diff < 0 ) {
			tick_diff = -tick_diff;
			sign = '-';
		}
		if ( tick_diff ) {
			if ( tick_diff < tb_ticks_per_jiffy/25 ) {
				printk( "Titan recalibrate: new tb_ticks_per_jiffy = %lu (%c%ld)\n",
						new_tb_ticks_per_jiffy, sign, tick_diff );
				tb_ticks_per_jiffy = new_tb_ticks_per_jiffy;
				tb_ticks_per_sec   = new_tb_ticks_per_sec;
493
				calc_cputime_factors();
Linus Torvalds's avatar
Linus Torvalds committed
494
495
496
497
				div128_by_32( XSEC_PER_SEC, 0, tb_ticks_per_sec, &divres );
				do_gtod.tb_ticks_per_sec = tb_ticks_per_sec;
				tb_to_xs = divres.result_low;
				do_gtod.varp->tb_to_xs = tb_to_xs;
498
499
				vdso_data->tb_ticks_per_sec = tb_ticks_per_sec;
				vdso_data->tb_to_xs = tb_to_xs;
Linus Torvalds's avatar
Linus Torvalds committed
500
501
502
503
504
505
506
507
508
509
510
			}
			else {
				printk( "Titan recalibrate: FAILED (difference > 4 percent)\n"
					"                   new tb_ticks_per_jiffy = %lu\n"
					"                   old tb_ticks_per_jiffy = %lu\n",
					new_tb_ticks_per_jiffy, tb_ticks_per_jiffy );
			}
		}
	}
	iSeries_recal_titan = titan;
	iSeries_recal_tb = tb;
511

512
513
	/* Called here as now we know accurate values for the timebase */
	clocksource_init();
514
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
515
}
516
517
518
519
520
521
522
523
524
late_initcall(iSeries_tb_recal);

/* Called from platform early init */
void __init iSeries_time_init_early(void)
{
	iSeries_recal_tb = get_tb();
	iSeries_recal_titan = HvCallXm_loadTod();
}
#endif /* CONFIG_PPC_ISERIES */
Linus Torvalds's avatar
Linus Torvalds committed
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539

/*
 * For iSeries shared processors, we have to let the hypervisor
 * set the hardware decrementer.  We set a virtual decrementer
 * in the lppaca and call the hypervisor if the virtual
 * decrementer is less than the current value in the hardware
 * decrementer. (almost always the new decrementer value will
 * be greater than the current hardware decementer so the hypervisor
 * call will not be needed)
 */

/*
 * timer_interrupt - gets called when the decrementer overflows,
 * with interrupts disabled.
 */
540
void timer_interrupt(struct pt_regs * regs)
Linus Torvalds's avatar
Linus Torvalds committed
541
{
542
	struct pt_regs *old_regs;
543
	int cpu = smp_processor_id();
544
	struct clock_event_device *evt = &per_cpu(decrementers, cpu);
545
	u64 now;
546
547
548
549

	/* Ensure a positive value is written to the decrementer, or else
	 * some CPUs will continuue to take decrementer exceptions */
	set_dec(DECREMENTER_MAX);
550
551
552
553
554

#ifdef CONFIG_PPC32
	if (atomic_read(&ppc_n_lost_interrupts) != 0)
		do_IRQ(regs);
#endif
Linus Torvalds's avatar
Linus Torvalds committed
555

556
557
558
559
560
561
562
563
	now = get_tb_or_rtc();
	if (now < per_cpu(decrementer_next_tb, cpu)) {
		/* not time for this event yet */
		now = per_cpu(decrementer_next_tb, cpu) - now;
		if (now <= DECREMENTER_MAX)
			set_dec((unsigned int)now - 1);
		return;
	}
564
	old_regs = set_irq_regs(regs);
Linus Torvalds's avatar
Linus Torvalds committed
565
566
	irq_enter();

567
	calculate_steal_time();
Linus Torvalds's avatar
Linus Torvalds committed
568

569
#ifdef CONFIG_PPC_ISERIES
570
571
	if (firmware_has_feature(FW_FEATURE_ISERIES))
		get_lppaca()->int_dword.fields.decr_int = 0;
572
573
#endif

574
575
576
577
578
579
580
581
582
	/*
	 * We cannot disable the decrementer, so in the period
	 * between this cpu's being marked offline in cpu_online_map
	 * and calling stop-self, it is taking timer interrupts.
	 * Avoid calling into the scheduler rebalancing code if this
	 * is the case.
	 */
	if (!cpu_is_offline(cpu))
		account_process_time(regs);
583

584
585
586
587
	if (evt->event_handler)
		evt->event_handler(evt);
	else
		evt->set_next_event(DECREMENTER_MAX, evt);
Linus Torvalds's avatar
Linus Torvalds committed
588
589

#ifdef CONFIG_PPC_ISERIES
590
	if (firmware_has_feature(FW_FEATURE_ISERIES) && hvlpevent_is_pending())
591
		process_hvlpevents();
Linus Torvalds's avatar
Linus Torvalds committed
592
593
#endif

594
#ifdef CONFIG_PPC64
595
	/* collect purr register values often, for accurate calculations */
596
	if (firmware_has_feature(FW_FEATURE_SPLPAR)) {
Linus Torvalds's avatar
Linus Torvalds committed
597
598
599
		struct cpu_usage *cu = &__get_cpu_var(cpu_usage_array);
		cu->current_tb = mfspr(SPRN_PURR);
	}
600
#endif
Linus Torvalds's avatar
Linus Torvalds committed
601
602

	irq_exit();
603
	set_irq_regs(old_regs);
Linus Torvalds's avatar
Linus Torvalds committed
604
605
}

606
607
void wakeup_decrementer(void)
{
608
	unsigned long ticks;
609
610

	/*
611
612
	 * The timebase gets saved on sleep and restored on wakeup,
	 * so all we need to do is to reset the decrementer.
613
	 */
614
615
616
617
618
619
	ticks = tb_ticks_since(__get_cpu_var(last_jiffy));
	if (ticks < tb_ticks_per_jiffy)
		ticks = tb_ticks_per_jiffy - ticks;
	else
		ticks = 1;
	set_dec(ticks);
620
621
}

622
#ifdef CONFIG_SMP
623
624
625
void __init smp_space_timers(unsigned int max_cpus)
{
	int i;
626
	u64 previous_tb = per_cpu(last_jiffy, boot_cpuid);
627

628
629
	/* make sure tb > per_cpu(last_jiffy, cpu) for all cpus always */
	previous_tb -= tb_ticks_per_jiffy;
630

631
	for_each_possible_cpu(i) {
632
633
		if (i == boot_cpuid)
			continue;
634
		per_cpu(last_jiffy, i) = previous_tb;
635
636
637
638
	}
}
#endif

Linus Torvalds's avatar
Linus Torvalds committed
639
640
641
642
643
644
645
646
647
/*
 * Scheduler clock - returns current time in nanosec units.
 *
 * Note: mulhdu(a, b) (multiply high double unsigned) returns
 * the high 64 bits of a * b, i.e. (a * b) >> 64, where a and b
 * are 64-bit unsigned numbers.
 */
unsigned long long sched_clock(void)
{
648
649
	if (__USE_RTC())
		return get_rtc();
650
	return mulhdu(get_tb() - boot_tb, tb_to_ns_scale) << tb_to_ns_shift;
Linus Torvalds's avatar
Linus Torvalds committed
651
652
}

653
static int __init get_freq(char *name, int cells, unsigned long *val)
654
655
{
	struct device_node *cpu;
656
	const unsigned int *fp;
657
	int found = 0;
658

659
	/* The cpu node should have timebase and clock frequency properties */
660
661
	cpu = of_find_node_by_type(NULL, "cpu");

662
	if (cpu) {
663
		fp = of_get_property(cpu, name, NULL);
664
		if (fp) {
665
			found = 1;
666
			*val = of_read_ulong(fp, cells);
667
		}
668
669

		of_node_put(cpu);
670
	}
671
672
673
674
675
676
677
678
679
680
681

	return found;
}

void __init generic_calibrate_decr(void)
{
	ppc_tb_freq = DEFAULT_TB_FREQ;		/* hardcoded default */

	if (!get_freq("ibm,extended-timebase-frequency", 2, &ppc_tb_freq) &&
	    !get_freq("timebase-frequency", 1, &ppc_tb_freq)) {

682
683
		printk(KERN_ERR "WARNING: Estimating decrementer frequency "
				"(not found)\n");
684
	}
685

686
687
688
689
690
691
692
	ppc_proc_freq = DEFAULT_PROC_FREQ;	/* hardcoded default */

	if (!get_freq("ibm,extended-clock-frequency", 2, &ppc_proc_freq) &&
	    !get_freq("clock-frequency", 1, &ppc_proc_freq)) {

		printk(KERN_ERR "WARNING: Estimating processor frequency "
				"(not found)\n");
693
	}
694

Josh Boyer's avatar
Josh Boyer committed
695
#if defined(CONFIG_BOOKE) || defined(CONFIG_40x)
696
697
698
699
700
701
702
703
704
705
	/* Set the time base to zero */
	mtspr(SPRN_TBWL, 0);
	mtspr(SPRN_TBWU, 0);

	/* Clear any pending timer interrupts */
	mtspr(SPRN_TSR, TSR_ENW | TSR_WIS | TSR_DIS | TSR_FIS);

	/* Enable decrementer interrupt */
	mtspr(SPRN_TCR, TCR_DIE);
#endif
706
707
}

708
int update_persistent_clock(struct timespec now)
709
710
711
{
	struct rtc_time tm;

712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
	if (!ppc_md.set_rtc_time)
		return 0;

	to_tm(now.tv_sec + 1 + timezone_offset, &tm);
	tm.tm_year -= 1900;
	tm.tm_mon -= 1;

	return ppc_md.set_rtc_time(&tm);
}

unsigned long read_persistent_clock(void)
{
	struct rtc_time tm;
	static int first = 1;

	/* XXX this is a litle fragile but will work okay in the short term */
	if (first) {
		first = 0;
		if (ppc_md.time_init)
			timezone_offset = ppc_md.time_init();

		/* get_boot_time() isn't guaranteed to be safe to call late */
		if (ppc_md.get_boot_time)
			return ppc_md.get_boot_time() -timezone_offset;
	}
737
738
739
740
741
742
743
	if (!ppc_md.get_rtc_time)
		return 0;
	ppc_md.get_rtc_time(&tm);
	return mktime(tm.tm_year+1900, tm.tm_mon+1, tm.tm_mday,
		      tm.tm_hour, tm.tm_min, tm.tm_sec);
}

744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
/* clocksource code */
static cycle_t rtc_read(void)
{
	return (cycle_t)get_rtc();
}

static cycle_t timebase_read(void)
{
	return (cycle_t)get_tb();
}

void update_vsyscall(struct timespec *wall_time, struct clocksource *clock)
{
	u64 t2x, stamp_xsec;

	if (clock != &clocksource_timebase)
		return;

	/* Make userspace gettimeofday spin until we're done. */
	++vdso_data->tb_update_count;
	smp_mb();

	/* XXX this assumes clock->shift == 22 */
	/* 4611686018 ~= 2^(20+64-22) / 1e9 */
	t2x = (u64) clock->mult * 4611686018ULL;
	stamp_xsec = (u64) xtime.tv_nsec * XSEC_PER_SEC;
	do_div(stamp_xsec, 1000000000);
	stamp_xsec += (u64) xtime.tv_sec * XSEC_PER_SEC;
	update_gtod(clock->cycle_last, stamp_xsec, t2x);
}

void update_vsyscall_tz(void)
{
	/* Make userspace gettimeofday spin until we're done. */
	++vdso_data->tb_update_count;
	smp_mb();
	vdso_data->tz_minuteswest = sys_tz.tz_minuteswest;
	vdso_data->tz_dsttime = sys_tz.tz_dsttime;
	smp_mb();
	++vdso_data->tb_update_count;
}

void __init clocksource_init(void)
{
	struct clocksource *clock;

	if (__USE_RTC())
		clock = &clocksource_rtc;
	else
		clock = &clocksource_timebase;

	clock->mult = clocksource_hz2mult(tb_ticks_per_sec, clock->shift);

	if (clocksource_register(clock)) {
		printk(KERN_ERR "clocksource: %s is already registered\n",
		       clock->name);
		return;
	}

	printk(KERN_INFO "clocksource: %s mult[%x] shift[%d] registered\n",
	       clock->name, clock->mult, clock->shift);
}

807
808
809
static int decrementer_set_next_event(unsigned long evt,
				      struct clock_event_device *dev)
{
810
811
812
813
	__get_cpu_var(decrementer_next_tb) = get_tb_or_rtc() + evt;
	/* The decrementer interrupts on the 0 -> -1 transition */
	if (evt)
		--evt;
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
	set_dec(evt);
	return 0;
}

static void decrementer_set_mode(enum clock_event_mode mode,
				 struct clock_event_device *dev)
{
	if (mode != CLOCK_EVT_MODE_ONESHOT)
		decrementer_set_next_event(DECREMENTER_MAX, dev);
}

static void register_decrementer_clockevent(int cpu)
{
	struct clock_event_device *dec = &per_cpu(decrementers, cpu);

	*dec = decrementer_clockevent;
	dec->cpumask = cpumask_of_cpu(cpu);

	printk(KERN_ERR "clockevent: %s mult[%lx] shift[%d] cpu[%d]\n",
	       dec->name, dec->mult, dec->shift, cpu);

	clockevents_register_device(dec);
}

void init_decrementer_clockevent(void)
{
	int cpu = smp_processor_id();

	decrementer_clockevent.mult = div_sc(ppc_tb_freq, NSEC_PER_SEC,
					     decrementer_clockevent.shift);
	decrementer_clockevent.max_delta_ns =
		clockevent_delta2ns(DECREMENTER_MAX, &decrementer_clockevent);
	decrementer_clockevent.min_delta_ns = 1000;

	register_decrementer_clockevent(cpu);
}

void secondary_cpu_time_init(void)
{
	/* FIME: Should make unrelatred change to move snapshot_timebase
	 * call here ! */
	register_decrementer_clockevent(smp_processor_id());
}

858
/* This function is only called on the boot processor */
Linus Torvalds's avatar
Linus Torvalds committed
859
860
861
862
void __init time_init(void)
{
	unsigned long flags;
	struct div_result res;
863
	u64 scale, x;
864
865
	unsigned shift;

866
867
868
	if (__USE_RTC()) {
		/* 601 processor: dec counts down by 128 every 128ns */
		ppc_tb_freq = 1000000000;
869
		tb_last_jiffy = get_rtcl();
870
871
872
	} else {
		/* Normal PowerPC with timebase register */
		ppc_md.calibrate_decr();
873
		printk(KERN_DEBUG "time_init: decrementer frequency = %lu.%.6lu MHz\n",
874
		       ppc_tb_freq / 1000000, ppc_tb_freq % 1000000);
875
		printk(KERN_DEBUG "time_init: processor frequency   = %lu.%.6lu MHz\n",
876
		       ppc_proc_freq / 1000000, ppc_proc_freq % 1000000);
877
		tb_last_jiffy = get_tb();
878
	}
879
880

	tb_ticks_per_jiffy = ppc_tb_freq / HZ;
881
	tb_ticks_per_sec = ppc_tb_freq;
882
883
	tb_ticks_per_usec = ppc_tb_freq / 1000000;
	tb_to_us = mulhwu_scale_factor(ppc_tb_freq, 1000000);
884
	calc_cputime_factors();
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902

	/*
	 * Calculate the length of each tick in ns.  It will not be
	 * exactly 1e9/HZ unless ppc_tb_freq is divisible by HZ.
	 * We compute 1e9 * tb_ticks_per_jiffy / ppc_tb_freq,
	 * rounded up.
	 */
	x = (u64) NSEC_PER_SEC * tb_ticks_per_jiffy + ppc_tb_freq - 1;
	do_div(x, ppc_tb_freq);
	tick_nsec = x;
	last_tick_len = x << TICKLEN_SCALE;

	/*
	 * Compute ticklen_to_xs, which is a factor which gets multiplied
	 * by (last_tick_len << TICKLEN_SHIFT) to get a tb_to_xs value.
	 * It is computed as:
	 * ticklen_to_xs = 2^N / (tb_ticks_per_jiffy * 1e9)
	 * where N = 64 + 20 - TICKLEN_SCALE - TICKLEN_SHIFT
903
904
905
906
907
908
909
	 * which turns out to be N = 51 - SHIFT_HZ.
	 * This gives the result as a 0.64 fixed-point fraction.
	 * That value is reduced by an offset amounting to 1 xsec per
	 * 2^31 timebase ticks to avoid problems with time going backwards
	 * by 1 xsec when we do timer_recalc_offset due to losing the
	 * fractional xsec.  That offset is equal to ppc_tb_freq/2^51
	 * since there are 2^20 xsec in a second.
910
	 */
911
912
	div128_by_32((1ULL << 51) - ppc_tb_freq, 0,
		     tb_ticks_per_jiffy << SHIFT_HZ, &res);
913
914
915
916
917
	div128_by_32(res.result_high, res.result_low, NSEC_PER_SEC, &res);
	ticklen_to_xs = res.result_low;

	/* Compute tb_to_xs from tick_nsec */
	tb_to_xs = mulhdu(last_tick_len << TICKLEN_SHIFT, ticklen_to_xs);
918

Linus Torvalds's avatar
Linus Torvalds committed
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
	/*
	 * Compute scale factor for sched_clock.
	 * The calibrate_decr() function has set tb_ticks_per_sec,
	 * which is the timebase frequency.
	 * We compute 1e9 * 2^64 / tb_ticks_per_sec and interpret
	 * the 128-bit result as a 64.64 fixed-point number.
	 * We then shift that number right until it is less than 1.0,
	 * giving us the scale factor and shift count to use in
	 * sched_clock().
	 */
	div128_by_32(1000000000, 0, tb_ticks_per_sec, &res);
	scale = res.result_low;
	for (shift = 0; res.result_high != 0; ++shift) {
		scale = (scale >> 1) | (res.result_high << 63);
		res.result_high >>= 1;
	}
	tb_to_ns_scale = scale;
	tb_to_ns_shift = shift;
937
	/* Save the current timebase to pretty up CONFIG_PRINTK_TIME */
938
	boot_tb = get_tb_or_rtc();
Linus Torvalds's avatar
Linus Torvalds committed
939
940

	write_seqlock_irqsave(&xtime_lock, flags);
941
942
943
944
945
946
947

	/* If platform provided a timezone (pmac), we correct the time */
        if (timezone_offset) {
		sys_tz.tz_minuteswest = -timezone_offset / 60;
		sys_tz.tz_dsttime = 0;
        }

Linus Torvalds's avatar
Linus Torvalds committed
948
949
	do_gtod.varp = &do_gtod.vars[0];
	do_gtod.var_idx = 0;
950
	do_gtod.varp->tb_orig_stamp = tb_last_jiffy;
951
	__get_cpu_var(last_jiffy) = tb_last_jiffy;
952
	do_gtod.varp->stamp_xsec = (u64) xtime.tv_sec * XSEC_PER_SEC;
Linus Torvalds's avatar
Linus Torvalds committed
953
954
955
	do_gtod.tb_ticks_per_sec = tb_ticks_per_sec;
	do_gtod.varp->tb_to_xs = tb_to_xs;
	do_gtod.tb_to_us = tb_to_us;
956
957
958
959

	vdso_data->tb_orig_stamp = tb_last_jiffy;
	vdso_data->tb_update_count = 0;
	vdso_data->tb_ticks_per_sec = tb_ticks_per_sec;
960
	vdso_data->stamp_xsec = (u64) xtime.tv_sec * XSEC_PER_SEC;
961
	vdso_data->tb_to_xs = tb_to_xs;
Linus Torvalds's avatar
Linus Torvalds committed
962
963
964
965
966

	time_freq = 0;

	write_sequnlock_irqrestore(&xtime_lock, flags);

967
968
969
970
	/* Register the clocksource, if we're not running on iSeries */
	if (!firmware_has_feature(FW_FEATURE_ISERIES))
		clocksource_init();

971
	init_decrementer_clockevent();
Linus Torvalds's avatar
Linus Torvalds committed
972
973
974
975
976
977
978
}


#define FEBRUARY	2
#define	STARTOFTIME	1970
#define SECDAY		86400L
#define SECYR		(SECDAY * 365)
979
980
#define	leapyear(year)		((year) % 4 == 0 && \
				 ((year) % 100 != 0 || (year) % 400 == 0))
Linus Torvalds's avatar
Linus Torvalds committed
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
#define	days_in_year(a) 	(leapyear(a) ? 366 : 365)
#define	days_in_month(a) 	(month_days[(a) - 1])

static int month_days[12] = {
	31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
};

/*
 * This only works for the Gregorian calendar - i.e. after 1752 (in the UK)
 */
void GregorianDay(struct rtc_time * tm)
{
	int leapsToDate;
	int lastYear;
	int day;
	int MonthOffset[] = { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 };

998
	lastYear = tm->tm_year - 1;
Linus Torvalds's avatar
Linus Torvalds committed
999
1000
1001
1002

	/*
	 * Number of leap corrections to apply up to end of last year
	 */
1003
	leapsToDate = lastYear / 4 - lastYear / 100 + lastYear / 400;
Linus Torvalds's avatar
Linus Torvalds committed
1004
1005
1006
1007
1008

	/*
	 * This year is a leap year if it is divisible by 4 except when it is
	 * divisible by 100 unless it is divisible by 400
	 *
1009
	 * e.g. 1904 was a leap year, 1900 was not, 1996 is, and 2000 was
Linus Torvalds's avatar
Linus Torvalds committed
1010
	 */
1011
	day = tm->tm_mon > 2 && leapyear(tm->tm_year);
Linus Torvalds's avatar
Linus Torvalds committed
1012
1013
1014
1015

	day += lastYear*365 + leapsToDate + MonthOffset[tm->tm_mon-1] +
		   tm->tm_mday;

1016
	tm->tm_wday = day % 7;
Linus Torvalds's avatar
Linus Torvalds committed
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
}

void to_tm(int tim, struct rtc_time * tm)
{
	register int    i;
	register long   hms, day;

	day = tim / SECDAY;
	hms = tim % SECDAY;

	/* Hours, minutes, seconds are easy */
	tm->tm_hour = hms / 3600;
	tm->tm_min = (hms % 3600) / 60;
	tm->tm_sec = (hms % 3600) % 60;

	/* Number of years in days */
	for (i = STARTOFTIME; day >= days_in_year(i); i++)
		day -= days_in_year(i);
	tm->tm_year = i;

	/* Number of months in days left */
	if (leapyear(tm->tm_year))
		days_in_month(FEBRUARY) = 29;
	for (i = 1; day >= days_in_month(i); i++)
		day -= days_in_month(i);
	days_in_month(FEBRUARY) = 28;
	tm->tm_mon = i;

	/* Days are what is left over (+1) from all that. */
	tm->tm_mday = day + 1;

	/*
	 * Determine the day of week
	 */
	GregorianDay(tm);
}

/* Auxiliary function to compute scaling factors */
/* Actually the choice of a timebase running at 1/4 the of the bus
 * frequency giving resolution of a few tens of nanoseconds is quite nice.
 * It makes this computation very precise (27-28 bits typically) which
 * is optimistic considering the stability of most processor clock
 * oscillators and the precision with which the timebase frequency
 * is measured but does not harm.
 */
1062
1063
unsigned mulhwu_scale_factor(unsigned inscale, unsigned outscale)
{
Linus Torvalds's avatar
Linus Torvalds committed
1064
1065
1066
1067
1068
1069
        unsigned mlt=0, tmp, err;
        /* No concern for performance, it's done once: use a stupid
         * but safe and compact method to find the multiplier.
         */
  
        for (tmp = 1U<<31; tmp != 0; tmp >>= 1) {
1070
1071
                if (mulhwu(inscale, mlt|tmp) < outscale)
			mlt |= tmp;
Linus Torvalds's avatar
Linus Torvalds committed
1072
1073
1074
1075
1076
1077
1078
1079
1080
        }
  
        /* We might still be off by 1 for the best approximation.
         * A side effect of this is that if outscale is too large
         * the returned value will be zero.
         * Many corner cases have been checked and seem to work,
         * some might have been forgotten in the test however.
         */
  
1081
1082
1083
        err = inscale * (mlt+1);
        if (err <= inscale/2)
		mlt++;
Linus Torvalds's avatar
Linus Torvalds committed
1084
        return mlt;
1085
}
Linus Torvalds's avatar
Linus Torvalds committed
1086
1087
1088
1089
1090

/*
 * Divide a 128-bit dividend by a 32-bit divisor, leaving a 128 bit
 * result.
 */
1091
1092
void div128_by_32(u64 dividend_high, u64 dividend_low,
		  unsigned divisor, struct div_result *dr)
Linus Torvalds's avatar
Linus Torvalds committed
1093
{
1094
1095
1096
	unsigned long a, b, c, d;
	unsigned long w, x, y, z;
	u64 ra, rb, rc;
Linus Torvalds's avatar
Linus Torvalds committed
1097
1098
1099
1100
1101
1102

	a = dividend_high >> 32;
	b = dividend_high & 0xffffffff;
	c = dividend_low >> 32;
	d = dividend_low & 0xffffffff;

1103
1104
1105
1106
1107
	w = a / divisor;
	ra = ((u64)(a - (w * divisor)) << 32) + b;

	rb = ((u64) do_div(ra, divisor) << 32) + c;
	x = ra;
Linus Torvalds's avatar
Linus Torvalds committed
1108

1109
1110
1111
1112
1113
	rc = ((u64) do_div(rb, divisor) << 32) + d;
	y = rb;

	do_div(rc, divisor);
	z = rc;
Linus Torvalds's avatar
Linus Torvalds committed
1114

1115
1116
	dr->result_high = ((u64)w << 32) + x;
	dr->result_low  = ((u64)y << 32) + z;
Linus Torvalds's avatar
Linus Torvalds committed
1117
1118

}