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#include <linux/errno.h>
36#include <linux/module.h>
37#include <linux/sched.h>
38#include <linux/kernel.h>
39#include <linux/param.h>
40#include <linux/string.h>
41#include <linux/mm.h>
42#include <linux/interrupt.h>
43#include <linux/timex.h>
44#include <linux/kernel_stat.h>
45#include <linux/time.h>
46#include <linux/init.h>
47#include <linux/profile.h>
48#include <linux/cpu.h>
49#include <linux/security.h>
50#include <linux/percpu.h>
51#include <linux/rtc.h>
52#include <linux/jiffies.h>
53#include <linux/posix-timers.h>
54#include <linux/irq.h>
55#include <linux/delay.h>
56#include <linux/irq_work.h>
57#include <asm/trace.h>
58
59#include <asm/io.h>
60#include <asm/processor.h>
61#include <asm/nvram.h>
62#include <asm/cache.h>
63#include <asm/machdep.h>
64#include <asm/uaccess.h>
65#include <asm/time.h>
66#include <asm/prom.h>
67#include <asm/irq.h>
68#include <asm/div64.h>
69#include <asm/smp.h>
70#include <asm/vdso_datapage.h>
71#include <asm/firmware.h>
72#include <asm/cputime.h>
73#ifdef CONFIG_PPC_ISERIES
74#include <asm/iseries/it_lp_queue.h>
75#include <asm/iseries/hv_call_xm.h>
76#endif
77
78
79
80#include <linux/clockchips.h>
81#include <linux/clocksource.h>
82
83static cycle_t rtc_read(struct clocksource *);
84static struct clocksource clocksource_rtc = {
85 .name = "rtc",
86 .rating = 400,
87 .flags = CLOCK_SOURCE_IS_CONTINUOUS,
88 .mask = CLOCKSOURCE_MASK(64),
89 .shift = 22,
90 .mult = 0,
91 .read = rtc_read,
92};
93
94static cycle_t timebase_read(struct clocksource *);
95static struct clocksource clocksource_timebase = {
96 .name = "timebase",
97 .rating = 400,
98 .flags = CLOCK_SOURCE_IS_CONTINUOUS,
99 .mask = CLOCKSOURCE_MASK(64),
100 .shift = 22,
101 .mult = 0,
102 .read = timebase_read,
103};
104
105#define DECREMENTER_MAX 0x7fffffff
106
107static int decrementer_set_next_event(unsigned long evt,
108 struct clock_event_device *dev);
109static void decrementer_set_mode(enum clock_event_mode mode,
110 struct clock_event_device *dev);
111
112static struct clock_event_device decrementer_clockevent = {
113 .name = "decrementer",
114 .rating = 200,
115 .shift = 0,
116 .mult = 0,
117 .irq = 0,
118 .set_next_event = decrementer_set_next_event,
119 .set_mode = decrementer_set_mode,
120 .features = CLOCK_EVT_FEAT_ONESHOT,
121};
122
123struct decrementer_clock {
124 struct clock_event_device event;
125 u64 next_tb;
126};
127
128static DEFINE_PER_CPU(struct decrementer_clock, decrementers);
129
130#ifdef CONFIG_PPC_ISERIES
131static unsigned long __initdata iSeries_recal_titan;
132static signed long __initdata iSeries_recal_tb;
133
134
135static void __init clocksource_init(void);
136#endif
137
138#define XSEC_PER_SEC (1024*1024)
139
140#ifdef CONFIG_PPC64
141#define SCALE_XSEC(xsec, max) (((xsec) * max) / XSEC_PER_SEC)
142#else
143
144#define SCALE_XSEC(xsec, max) mulhwu((xsec) << 12, max)
145#endif
146
147unsigned long tb_ticks_per_jiffy;
148unsigned long tb_ticks_per_usec = 100;
149EXPORT_SYMBOL(tb_ticks_per_usec);
150unsigned long tb_ticks_per_sec;
151EXPORT_SYMBOL(tb_ticks_per_sec);
152
153DEFINE_SPINLOCK(rtc_lock);
154EXPORT_SYMBOL_GPL(rtc_lock);
155
156static u64 tb_to_ns_scale __read_mostly;
157static unsigned tb_to_ns_shift __read_mostly;
158static u64 boot_tb __read_mostly;
159
160extern struct timezone sys_tz;
161static long timezone_offset;
162
163unsigned long ppc_proc_freq;
164EXPORT_SYMBOL_GPL(ppc_proc_freq);
165unsigned long ppc_tb_freq;
166EXPORT_SYMBOL_GPL(ppc_tb_freq);
167
168#ifdef CONFIG_VIRT_CPU_ACCOUNTING
169
170
171
172
173
174u64 __cputime_jiffies_factor;
175EXPORT_SYMBOL(__cputime_jiffies_factor);
176u64 __cputime_msec_factor;
177EXPORT_SYMBOL(__cputime_msec_factor);
178u64 __cputime_sec_factor;
179EXPORT_SYMBOL(__cputime_sec_factor);
180u64 __cputime_clockt_factor;
181EXPORT_SYMBOL(__cputime_clockt_factor);
182DEFINE_PER_CPU(unsigned long, cputime_last_delta);
183DEFINE_PER_CPU(unsigned long, cputime_scaled_last_delta);
184
185cputime_t cputime_one_jiffy;
186
187void (*dtl_consumer)(struct dtl_entry *, u64);
188
189static void calc_cputime_factors(void)
190{
191 struct div_result res;
192
193 div128_by_32(HZ, 0, tb_ticks_per_sec, &res);
194 __cputime_jiffies_factor = res.result_low;
195 div128_by_32(1000, 0, tb_ticks_per_sec, &res);
196 __cputime_msec_factor = res.result_low;
197 div128_by_32(1, 0, tb_ticks_per_sec, &res);
198 __cputime_sec_factor = res.result_low;
199 div128_by_32(USER_HZ, 0, tb_ticks_per_sec, &res);
200 __cputime_clockt_factor = res.result_low;
201}
202
203
204
205
206
207static u64 read_spurr(u64 tb)
208{
209 if (cpu_has_feature(CPU_FTR_SPURR))
210 return mfspr(SPRN_SPURR);
211 if (cpu_has_feature(CPU_FTR_PURR))
212 return mfspr(SPRN_PURR);
213 return tb;
214}
215
216#ifdef CONFIG_PPC_SPLPAR
217
218
219
220
221
222static u64 scan_dispatch_log(u64 stop_tb)
223{
224 u64 i = local_paca->dtl_ridx;
225 struct dtl_entry *dtl = local_paca->dtl_curr;
226 struct dtl_entry *dtl_end = local_paca->dispatch_log_end;
227 struct lppaca *vpa = local_paca->lppaca_ptr;
228 u64 tb_delta;
229 u64 stolen = 0;
230 u64 dtb;
231
232 if (i == vpa->dtl_idx)
233 return 0;
234 while (i < vpa->dtl_idx) {
235 if (dtl_consumer)
236 dtl_consumer(dtl, i);
237 dtb = dtl->timebase;
238 tb_delta = dtl->enqueue_to_dispatch_time +
239 dtl->ready_to_enqueue_time;
240 barrier();
241 if (i + N_DISPATCH_LOG < vpa->dtl_idx) {
242
243 i = vpa->dtl_idx - N_DISPATCH_LOG;
244 dtl = local_paca->dispatch_log + (i % N_DISPATCH_LOG);
245 continue;
246 }
247 if (dtb > stop_tb)
248 break;
249 stolen += tb_delta;
250 ++i;
251 ++dtl;
252 if (dtl == dtl_end)
253 dtl = local_paca->dispatch_log;
254 }
255 local_paca->dtl_ridx = i;
256 local_paca->dtl_curr = dtl;
257 return stolen;
258}
259
260
261
262
263
264void accumulate_stolen_time(void)
265{
266 u64 sst, ust;
267
268 u8 save_soft_enabled = local_paca->soft_enabled;
269 u8 save_hard_enabled = local_paca->hard_enabled;
270
271
272
273
274
275
276
277 local_paca->soft_enabled = 0;
278 local_paca->hard_enabled = 0;
279
280 sst = scan_dispatch_log(local_paca->starttime_user);
281 ust = scan_dispatch_log(local_paca->starttime);
282 local_paca->system_time -= sst;
283 local_paca->user_time -= ust;
284 local_paca->stolen_time += ust + sst;
285
286 local_paca->soft_enabled = save_soft_enabled;
287 local_paca->hard_enabled = save_hard_enabled;
288}
289
290static inline u64 calculate_stolen_time(u64 stop_tb)
291{
292 u64 stolen = 0;
293
294 if (get_paca()->dtl_ridx != get_paca()->lppaca_ptr->dtl_idx) {
295 stolen = scan_dispatch_log(stop_tb);
296 get_paca()->system_time -= stolen;
297 }
298
299 stolen += get_paca()->stolen_time;
300 get_paca()->stolen_time = 0;
301 return stolen;
302}
303
304#else
305static inline u64 calculate_stolen_time(u64 stop_tb)
306{
307 return 0;
308}
309
310#endif
311
312
313
314
315
316void account_system_vtime(struct task_struct *tsk)
317{
318 u64 now, nowscaled, delta, deltascaled;
319 unsigned long flags;
320 u64 stolen, udelta, sys_scaled, user_scaled;
321
322 local_irq_save(flags);
323 now = mftb();
324 nowscaled = read_spurr(now);
325 get_paca()->system_time += now - get_paca()->starttime;
326 get_paca()->starttime = now;
327 deltascaled = nowscaled - get_paca()->startspurr;
328 get_paca()->startspurr = nowscaled;
329
330 stolen = calculate_stolen_time(now);
331
332 delta = get_paca()->system_time;
333 get_paca()->system_time = 0;
334 udelta = get_paca()->user_time - get_paca()->utime_sspurr;
335 get_paca()->utime_sspurr = get_paca()->user_time;
336
337
338
339
340
341
342
343
344
345
346
347 sys_scaled = delta;
348 user_scaled = udelta;
349 if (deltascaled != delta + udelta) {
350 if (udelta) {
351 sys_scaled = deltascaled * delta / (delta + udelta);
352 user_scaled = deltascaled - sys_scaled;
353 } else {
354 sys_scaled = deltascaled;
355 }
356 }
357 get_paca()->user_time_scaled += user_scaled;
358
359 if (in_irq() || idle_task(smp_processor_id()) != tsk) {
360 account_system_time(tsk, 0, delta, sys_scaled);
361 if (stolen)
362 account_steal_time(stolen);
363 } else {
364 account_idle_time(delta + stolen);
365 }
366 local_irq_restore(flags);
367}
368EXPORT_SYMBOL_GPL(account_system_vtime);
369
370
371
372
373
374
375
376
377
378
379void account_process_tick(struct task_struct *tsk, int user_tick)
380{
381 cputime_t utime, utimescaled;
382
383 utime = get_paca()->user_time;
384 utimescaled = get_paca()->user_time_scaled;
385 get_paca()->user_time = 0;
386 get_paca()->user_time_scaled = 0;
387 get_paca()->utime_sspurr = 0;
388 account_user_time(tsk, utime, utimescaled);
389}
390
391#else
392#define calc_cputime_factors()
393#endif
394
395void __delay(unsigned long loops)
396{
397 unsigned long start;
398 int diff;
399
400 if (__USE_RTC()) {
401 start = get_rtcl();
402 do {
403
404 diff = get_rtcl() - start;
405 if (diff < 0)
406 diff += 1000000000;
407 } while (diff < loops);
408 } else {
409 start = get_tbl();
410 while (get_tbl() - start < loops)
411 HMT_low();
412 HMT_medium();
413 }
414}
415EXPORT_SYMBOL(__delay);
416
417void udelay(unsigned long usecs)
418{
419 __delay(tb_ticks_per_usec * usecs);
420}
421EXPORT_SYMBOL(udelay);
422
423#ifdef CONFIG_SMP
424unsigned long profile_pc(struct pt_regs *regs)
425{
426 unsigned long pc = instruction_pointer(regs);
427
428 if (in_lock_functions(pc))
429 return regs->link;
430
431 return pc;
432}
433EXPORT_SYMBOL(profile_pc);
434#endif
435
436#ifdef CONFIG_PPC_ISERIES
437
438
439
440
441
442
443
444static int __init iSeries_tb_recal(void)
445{
446 unsigned long titan, tb;
447
448
449 if (!firmware_has_feature(FW_FEATURE_ISERIES))
450 return -ENODEV;
451
452 tb = get_tb();
453 titan = HvCallXm_loadTod();
454 if ( iSeries_recal_titan ) {
455 unsigned long tb_ticks = tb - iSeries_recal_tb;
456 unsigned long titan_usec = (titan - iSeries_recal_titan) >> 12;
457 unsigned long new_tb_ticks_per_sec = (tb_ticks * USEC_PER_SEC)/titan_usec;
458 unsigned long new_tb_ticks_per_jiffy =
459 DIV_ROUND_CLOSEST(new_tb_ticks_per_sec, HZ);
460 long tick_diff = new_tb_ticks_per_jiffy - tb_ticks_per_jiffy;
461 char sign = '+';
462
463 new_tb_ticks_per_sec = new_tb_ticks_per_jiffy * HZ;
464
465 if ( tick_diff < 0 ) {
466 tick_diff = -tick_diff;
467 sign = '-';
468 }
469 if ( tick_diff ) {
470 if ( tick_diff < tb_ticks_per_jiffy/25 ) {
471 printk( "Titan recalibrate: new tb_ticks_per_jiffy = %lu (%c%ld)\n",
472 new_tb_ticks_per_jiffy, sign, tick_diff );
473 tb_ticks_per_jiffy = new_tb_ticks_per_jiffy;
474 tb_ticks_per_sec = new_tb_ticks_per_sec;
475 calc_cputime_factors();
476 vdso_data->tb_ticks_per_sec = tb_ticks_per_sec;
477 setup_cputime_one_jiffy();
478 }
479 else {
480 printk( "Titan recalibrate: FAILED (difference > 4 percent)\n"
481 " new tb_ticks_per_jiffy = %lu\n"
482 " old tb_ticks_per_jiffy = %lu\n",
483 new_tb_ticks_per_jiffy, tb_ticks_per_jiffy );
484 }
485 }
486 }
487 iSeries_recal_titan = titan;
488 iSeries_recal_tb = tb;
489
490
491 clocksource_init();
492 return 0;
493}
494late_initcall(iSeries_tb_recal);
495
496
497void __init iSeries_time_init_early(void)
498{
499 iSeries_recal_tb = get_tb();
500 iSeries_recal_titan = HvCallXm_loadTod();
501}
502#endif
503
504#ifdef CONFIG_IRQ_WORK
505
506
507
508
509#ifdef CONFIG_PPC64
510static inline unsigned long test_irq_work_pending(void)
511{
512 unsigned long x;
513
514 asm volatile("lbz %0,%1(13)"
515 : "=r" (x)
516 : "i" (offsetof(struct paca_struct, irq_work_pending)));
517 return x;
518}
519
520static inline void set_irq_work_pending_flag(void)
521{
522 asm volatile("stb %0,%1(13)" : :
523 "r" (1),
524 "i" (offsetof(struct paca_struct, irq_work_pending)));
525}
526
527static inline void clear_irq_work_pending(void)
528{
529 asm volatile("stb %0,%1(13)" : :
530 "r" (0),
531 "i" (offsetof(struct paca_struct, irq_work_pending)));
532}
533
534#else
535
536DEFINE_PER_CPU(u8, irq_work_pending);
537
538#define set_irq_work_pending_flag() __get_cpu_var(irq_work_pending) = 1
539#define test_irq_work_pending() __get_cpu_var(irq_work_pending)
540#define clear_irq_work_pending() __get_cpu_var(irq_work_pending) = 0
541
542#endif
543
544void set_irq_work_pending(void)
545{
546 preempt_disable();
547 set_irq_work_pending_flag();
548 set_dec(1);
549 preempt_enable();
550}
551
552#else
553
554#define test_irq_work_pending() 0
555#define clear_irq_work_pending()
556
557#endif
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573void timer_interrupt(struct pt_regs * regs)
574{
575 struct pt_regs *old_regs;
576 struct decrementer_clock *decrementer = &__get_cpu_var(decrementers);
577 struct clock_event_device *evt = &decrementer->event;
578 u64 now;
579
580 trace_timer_interrupt_entry(regs);
581
582 __get_cpu_var(irq_stat).timer_irqs++;
583
584
585
586 set_dec(DECREMENTER_MAX);
587
588#if defined(CONFIG_PPC32) && defined(CONFIG_PMAC)
589 if (atomic_read(&ppc_n_lost_interrupts) != 0)
590 do_IRQ(regs);
591#endif
592
593 old_regs = set_irq_regs(regs);
594 irq_enter();
595
596 if (test_irq_work_pending()) {
597 clear_irq_work_pending();
598 irq_work_run();
599 }
600
601#ifdef CONFIG_PPC_ISERIES
602 if (firmware_has_feature(FW_FEATURE_ISERIES))
603 get_lppaca()->int_dword.fields.decr_int = 0;
604#endif
605
606 now = get_tb_or_rtc();
607 if (now >= decrementer->next_tb) {
608 decrementer->next_tb = ~(u64)0;
609 if (evt->event_handler)
610 evt->event_handler(evt);
611 } else {
612 now = decrementer->next_tb - now;
613 if (now <= DECREMENTER_MAX)
614 set_dec((int)now);
615 }
616
617#ifdef CONFIG_PPC_ISERIES
618 if (firmware_has_feature(FW_FEATURE_ISERIES) && hvlpevent_is_pending())
619 process_hvlpevents();
620#endif
621
622#ifdef CONFIG_PPC64
623
624 if (firmware_has_feature(FW_FEATURE_SPLPAR)) {
625 struct cpu_usage *cu = &__get_cpu_var(cpu_usage_array);
626 cu->current_tb = mfspr(SPRN_PURR);
627 }
628#endif
629
630 irq_exit();
631 set_irq_regs(old_regs);
632
633 trace_timer_interrupt_exit(regs);
634}
635
636#ifdef CONFIG_SUSPEND
637static void generic_suspend_disable_irqs(void)
638{
639
640
641
642
643 set_dec(0x7fffffff);
644 local_irq_disable();
645 set_dec(0x7fffffff);
646}
647
648static void generic_suspend_enable_irqs(void)
649{
650 local_irq_enable();
651}
652
653
654void arch_suspend_disable_irqs(void)
655{
656 if (ppc_md.suspend_disable_irqs)
657 ppc_md.suspend_disable_irqs();
658 generic_suspend_disable_irqs();
659}
660
661
662void arch_suspend_enable_irqs(void)
663{
664 generic_suspend_enable_irqs();
665 if (ppc_md.suspend_enable_irqs)
666 ppc_md.suspend_enable_irqs();
667}
668#endif
669
670
671
672
673
674
675
676
677unsigned long long sched_clock(void)
678{
679 if (__USE_RTC())
680 return get_rtc();
681 return mulhdu(get_tb() - boot_tb, tb_to_ns_scale) << tb_to_ns_shift;
682}
683
684static int __init get_freq(char *name, int cells, unsigned long *val)
685{
686 struct device_node *cpu;
687 const unsigned int *fp;
688 int found = 0;
689
690
691 cpu = of_find_node_by_type(NULL, "cpu");
692
693 if (cpu) {
694 fp = of_get_property(cpu, name, NULL);
695 if (fp) {
696 found = 1;
697 *val = of_read_ulong(fp, cells);
698 }
699
700 of_node_put(cpu);
701 }
702
703 return found;
704}
705
706
707void start_cpu_decrementer(void)
708{
709#if defined(CONFIG_BOOKE) || defined(CONFIG_40x)
710
711 mtspr(SPRN_TSR, TSR_ENW | TSR_WIS | TSR_DIS | TSR_FIS);
712
713
714 mtspr(SPRN_TCR, TCR_DIE);
715#endif
716}
717
718void __init generic_calibrate_decr(void)
719{
720 ppc_tb_freq = DEFAULT_TB_FREQ;
721
722 if (!get_freq("ibm,extended-timebase-frequency", 2, &ppc_tb_freq) &&
723 !get_freq("timebase-frequency", 1, &ppc_tb_freq)) {
724
725 printk(KERN_ERR "WARNING: Estimating decrementer frequency "
726 "(not found)\n");
727 }
728
729 ppc_proc_freq = DEFAULT_PROC_FREQ;
730
731 if (!get_freq("ibm,extended-clock-frequency", 2, &ppc_proc_freq) &&
732 !get_freq("clock-frequency", 1, &ppc_proc_freq)) {
733
734 printk(KERN_ERR "WARNING: Estimating processor frequency "
735 "(not found)\n");
736 }
737}
738
739int update_persistent_clock(struct timespec now)
740{
741 struct rtc_time tm;
742
743 if (!ppc_md.set_rtc_time)
744 return 0;
745
746 to_tm(now.tv_sec + 1 + timezone_offset, &tm);
747 tm.tm_year -= 1900;
748 tm.tm_mon -= 1;
749
750 return ppc_md.set_rtc_time(&tm);
751}
752
753static void __read_persistent_clock(struct timespec *ts)
754{
755 struct rtc_time tm;
756 static int first = 1;
757
758 ts->tv_nsec = 0;
759
760 if (first) {
761 first = 0;
762 if (ppc_md.time_init)
763 timezone_offset = ppc_md.time_init();
764
765
766 if (ppc_md.get_boot_time) {
767 ts->tv_sec = ppc_md.get_boot_time() - timezone_offset;
768 return;
769 }
770 }
771 if (!ppc_md.get_rtc_time) {
772 ts->tv_sec = 0;
773 return;
774 }
775 ppc_md.get_rtc_time(&tm);
776
777 ts->tv_sec = mktime(tm.tm_year+1900, tm.tm_mon+1, tm.tm_mday,
778 tm.tm_hour, tm.tm_min, tm.tm_sec);
779}
780
781void read_persistent_clock(struct timespec *ts)
782{
783 __read_persistent_clock(ts);
784
785
786 if (ts->tv_sec < 0) {
787 ts->tv_sec = 0;
788 ts->tv_nsec = 0;
789 }
790
791}
792
793
794static cycle_t rtc_read(struct clocksource *cs)
795{
796 return (cycle_t)get_rtc();
797}
798
799static cycle_t timebase_read(struct clocksource *cs)
800{
801 return (cycle_t)get_tb();
802}
803
804void update_vsyscall(struct timespec *wall_time, struct timespec *wtm,
805 struct clocksource *clock, u32 mult)
806{
807 u64 new_tb_to_xs, new_stamp_xsec;
808 u32 frac_sec;
809
810 if (clock != &clocksource_timebase)
811 return;
812
813
814 ++vdso_data->tb_update_count;
815 smp_mb();
816
817
818
819 new_tb_to_xs = (u64) mult * 4611686018ULL;
820 new_stamp_xsec = (u64) wall_time->tv_nsec * XSEC_PER_SEC;
821 do_div(new_stamp_xsec, 1000000000);
822 new_stamp_xsec += (u64) wall_time->tv_sec * XSEC_PER_SEC;
823
824 BUG_ON(wall_time->tv_nsec >= NSEC_PER_SEC);
825
826 frac_sec = ((u64) wall_time->tv_nsec * 18446744073ULL) >> 32;
827
828
829
830
831
832
833
834
835
836
837
838
839 vdso_data->tb_orig_stamp = clock->cycle_last;
840 vdso_data->stamp_xsec = new_stamp_xsec;
841 vdso_data->tb_to_xs = new_tb_to_xs;
842 vdso_data->wtom_clock_sec = wtm->tv_sec;
843 vdso_data->wtom_clock_nsec = wtm->tv_nsec;
844 vdso_data->stamp_xtime = *wall_time;
845 vdso_data->stamp_sec_fraction = frac_sec;
846 smp_wmb();
847 ++(vdso_data->tb_update_count);
848}
849
850void update_vsyscall_tz(void)
851{
852
853 ++vdso_data->tb_update_count;
854 smp_mb();
855 vdso_data->tz_minuteswest = sys_tz.tz_minuteswest;
856 vdso_data->tz_dsttime = sys_tz.tz_dsttime;
857 smp_mb();
858 ++vdso_data->tb_update_count;
859}
860
861static void __init clocksource_init(void)
862{
863 struct clocksource *clock;
864
865 if (__USE_RTC())
866 clock = &clocksource_rtc;
867 else
868 clock = &clocksource_timebase;
869
870 clock->mult = clocksource_hz2mult(tb_ticks_per_sec, clock->shift);
871
872 if (clocksource_register(clock)) {
873 printk(KERN_ERR "clocksource: %s is already registered\n",
874 clock->name);
875 return;
876 }
877
878 printk(KERN_INFO "clocksource: %s mult[%x] shift[%d] registered\n",
879 clock->name, clock->mult, clock->shift);
880}
881
882static int decrementer_set_next_event(unsigned long evt,
883 struct clock_event_device *dev)
884{
885 __get_cpu_var(decrementers).next_tb = get_tb_or_rtc() + evt;
886 set_dec(evt);
887 return 0;
888}
889
890static void decrementer_set_mode(enum clock_event_mode mode,
891 struct clock_event_device *dev)
892{
893 if (mode != CLOCK_EVT_MODE_ONESHOT)
894 decrementer_set_next_event(DECREMENTER_MAX, dev);
895}
896
897static inline uint64_t div_sc64(unsigned long ticks, unsigned long nsec,
898 int shift)
899{
900 uint64_t tmp = ((uint64_t)ticks) << shift;
901
902 do_div(tmp, nsec);
903 return tmp;
904}
905
906static void __init setup_clockevent_multiplier(unsigned long hz)
907{
908 u64 mult, shift = 32;
909
910 while (1) {
911 mult = div_sc64(hz, NSEC_PER_SEC, shift);
912 if (mult && (mult >> 32UL) == 0UL)
913 break;
914
915 shift--;
916 }
917
918 decrementer_clockevent.shift = shift;
919 decrementer_clockevent.mult = mult;
920}
921
922static void register_decrementer_clockevent(int cpu)
923{
924 struct clock_event_device *dec = &per_cpu(decrementers, cpu).event;
925
926 *dec = decrementer_clockevent;
927 dec->cpumask = cpumask_of(cpu);
928
929 printk_once(KERN_DEBUG "clockevent: %s mult[%x] shift[%d] cpu[%d]\n",
930 dec->name, dec->mult, dec->shift, cpu);
931
932 clockevents_register_device(dec);
933}
934
935static void __init init_decrementer_clockevent(void)
936{
937 int cpu = smp_processor_id();
938
939 setup_clockevent_multiplier(ppc_tb_freq);
940 decrementer_clockevent.max_delta_ns =
941 clockevent_delta2ns(DECREMENTER_MAX, &decrementer_clockevent);
942 decrementer_clockevent.min_delta_ns =
943 clockevent_delta2ns(2, &decrementer_clockevent);
944
945 register_decrementer_clockevent(cpu);
946}
947
948void secondary_cpu_time_init(void)
949{
950
951
952
953 start_cpu_decrementer();
954
955
956
957 register_decrementer_clockevent(smp_processor_id());
958}
959
960
961void __init time_init(void)
962{
963 struct div_result res;
964 u64 scale;
965 unsigned shift;
966
967 if (__USE_RTC()) {
968
969 ppc_tb_freq = 1000000000;
970 } else {
971
972 ppc_md.calibrate_decr();
973 printk(KERN_DEBUG "time_init: decrementer frequency = %lu.%.6lu MHz\n",
974 ppc_tb_freq / 1000000, ppc_tb_freq % 1000000);
975 printk(KERN_DEBUG "time_init: processor frequency = %lu.%.6lu MHz\n",
976 ppc_proc_freq / 1000000, ppc_proc_freq % 1000000);
977 }
978
979 tb_ticks_per_jiffy = ppc_tb_freq / HZ;
980 tb_ticks_per_sec = ppc_tb_freq;
981 tb_ticks_per_usec = ppc_tb_freq / 1000000;
982 calc_cputime_factors();
983 setup_cputime_one_jiffy();
984
985
986
987
988
989
990
991
992
993
994
995 div128_by_32(1000000000, 0, tb_ticks_per_sec, &res);
996 scale = res.result_low;
997 for (shift = 0; res.result_high != 0; ++shift) {
998 scale = (scale >> 1) | (res.result_high << 63);
999 res.result_high >>= 1;
1000 }
1001 tb_to_ns_scale = scale;
1002 tb_to_ns_shift = shift;
1003
1004 boot_tb = get_tb_or_rtc();
1005
1006
1007 if (timezone_offset) {
1008 sys_tz.tz_minuteswest = -timezone_offset / 60;
1009 sys_tz.tz_dsttime = 0;
1010 }
1011
1012 vdso_data->tb_update_count = 0;
1013 vdso_data->tb_ticks_per_sec = tb_ticks_per_sec;
1014
1015
1016
1017
1018 start_cpu_decrementer();
1019
1020
1021 if (!firmware_has_feature(FW_FEATURE_ISERIES))
1022 clocksource_init();
1023
1024 init_decrementer_clockevent();
1025}
1026
1027
1028#define FEBRUARY 2
1029#define STARTOFTIME 1970
1030#define SECDAY 86400L
1031#define SECYR (SECDAY * 365)
1032#define leapyear(year) ((year) % 4 == 0 && \
1033 ((year) % 100 != 0 || (year) % 400 == 0))
1034#define days_in_year(a) (leapyear(a) ? 366 : 365)
1035#define days_in_month(a) (month_days[(a) - 1])
1036
1037static int month_days[12] = {
1038 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
1039};
1040
1041
1042
1043
1044void GregorianDay(struct rtc_time * tm)
1045{
1046 int leapsToDate;
1047 int lastYear;
1048 int day;
1049 int MonthOffset[] = { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 };
1050
1051 lastYear = tm->tm_year - 1;
1052
1053
1054
1055
1056 leapsToDate = lastYear / 4 - lastYear / 100 + lastYear / 400;
1057
1058
1059
1060
1061
1062
1063
1064 day = tm->tm_mon > 2 && leapyear(tm->tm_year);
1065
1066 day += lastYear*365 + leapsToDate + MonthOffset[tm->tm_mon-1] +
1067 tm->tm_mday;
1068
1069 tm->tm_wday = day % 7;
1070}
1071
1072void to_tm(int tim, struct rtc_time * tm)
1073{
1074 register int i;
1075 register long hms, day;
1076
1077 day = tim / SECDAY;
1078 hms = tim % SECDAY;
1079
1080
1081 tm->tm_hour = hms / 3600;
1082 tm->tm_min = (hms % 3600) / 60;
1083 tm->tm_sec = (hms % 3600) % 60;
1084
1085
1086 for (i = STARTOFTIME; day >= days_in_year(i); i++)
1087 day -= days_in_year(i);
1088 tm->tm_year = i;
1089
1090
1091 if (leapyear(tm->tm_year))
1092 days_in_month(FEBRUARY) = 29;
1093 for (i = 1; day >= days_in_month(i); i++)
1094 day -= days_in_month(i);
1095 days_in_month(FEBRUARY) = 28;
1096 tm->tm_mon = i;
1097
1098
1099 tm->tm_mday = day + 1;
1100
1101
1102
1103
1104 GregorianDay(tm);
1105}
1106
1107
1108
1109
1110
1111void div128_by_32(u64 dividend_high, u64 dividend_low,
1112 unsigned divisor, struct div_result *dr)
1113{
1114 unsigned long a, b, c, d;
1115 unsigned long w, x, y, z;
1116 u64 ra, rb, rc;
1117
1118 a = dividend_high >> 32;
1119 b = dividend_high & 0xffffffff;
1120 c = dividend_low >> 32;
1121 d = dividend_low & 0xffffffff;
1122
1123 w = a / divisor;
1124 ra = ((u64)(a - (w * divisor)) << 32) + b;
1125
1126 rb = ((u64) do_div(ra, divisor) << 32) + c;
1127 x = ra;
1128
1129 rc = ((u64) do_div(rb, divisor) << 32) + d;
1130 y = rb;
1131
1132 do_div(rc, divisor);
1133 z = rc;
1134
1135 dr->result_high = ((u64)w << 32) + x;
1136 dr->result_low = ((u64)y << 32) + z;
1137
1138}
1139
1140
1141void calibrate_delay(void)
1142{
1143
1144
1145
1146 loops_per_jiffy = tb_ticks_per_jiffy;
1147}
1148
1149static int __init rtc_init(void)
1150{
1151 struct platform_device *pdev;
1152
1153 if (!ppc_md.get_rtc_time)
1154 return -ENODEV;
1155
1156 pdev = platform_device_register_simple("rtc-generic", -1, NULL, 0);
1157 if (IS_ERR(pdev))
1158 return PTR_ERR(pdev);
1159
1160 return 0;
1161}
1162
1163module_init(rtc_init);
1164