1 /* 2 * Common time routines among all ppc machines. 3 * 4 * Written by Cort Dougan (cort@cs.nmt.edu) to merge 5 * Paul Mackerras' version and mine for PReP and Pmac. 6 * MPC8xx/MBX changes by Dan Malek (dmalek@jlc.net). 7 * Converted for 64-bit by Mike Corrigan (mikejc@us.ibm.com) 8 * 9 * First round of bugfixes by Gabriel Paubert (paubert@iram.es) 10 * to make clock more stable (2.4.0-test5). The only thing 11 * that this code assumes is that the timebases have been synchronized 12 * by firmware on SMP and are never stopped (never do sleep 13 * on SMP then, nap and doze are OK). 14 * 15 * Speeded up do_gettimeofday by getting rid of references to 16 * xtime (which required locks for consistency). (mikejc@us.ibm.com) 17 * 18 * TODO (not necessarily in this file): 19 * - improve precision and reproducibility of timebase frequency 20 * measurement at boot time. (for iSeries, we calibrate the timebase 21 * against the Titan chip's clock.) 22 * - for astronomical applications: add a new function to get 23 * non ambiguous timestamps even around leap seconds. This needs 24 * a new timestamp format and a good name. 25 * 26 * 1997-09-10 Updated NTP code according to technical memorandum Jan '96 27 * "A Kernel Model for Precision Timekeeping" by Dave Mills 28 * 29 * This program is free software; you can redistribute it and/or 30 * modify it under the terms of the GNU General Public License 31 * as published by the Free Software Foundation; either version 32 * 2 of the License, or (at your option) any later version. 33 */ 34 35 #include <linux/config.h> 36 #include <linux/errno.h> 37 #include <linux/module.h> 38 #include <linux/sched.h> 39 #include <linux/kernel.h> 40 #include <linux/param.h> 41 #include <linux/string.h> 42 #include <linux/mm.h> 43 #include <linux/interrupt.h> 44 #include <linux/timex.h> 45 #include <linux/kernel_stat.h> 46 #include <linux/time.h> 47 #include <linux/init.h> 48 #include <linux/profile.h> 49 #include <linux/cpu.h> 50 #include <linux/security.h> 51 #include <linux/percpu.h> 52 #include <linux/rtc.h> 53 54 #include <asm/io.h> 55 #include <asm/processor.h> 56 #include <asm/nvram.h> 57 #include <asm/cache.h> 58 #include <asm/machdep.h> 59 #include <asm/uaccess.h> 60 #include <asm/time.h> 61 #include <asm/prom.h> 62 #include <asm/irq.h> 63 #include <asm/div64.h> 64 #include <asm/smp.h> 65 #include <asm/vdso_datapage.h> 66 #ifdef CONFIG_PPC64 67 #include <asm/firmware.h> 68 #endif 69 #ifdef CONFIG_PPC_ISERIES 70 #include <asm/iseries/it_lp_queue.h> 71 #include <asm/iseries/hv_call_xm.h> 72 #endif 73 #include <asm/smp.h> 74 75 /* keep track of when we need to update the rtc */ 76 time_t last_rtc_update; 77 extern int piranha_simulator; 78 #ifdef CONFIG_PPC_ISERIES 79 unsigned long iSeries_recal_titan = 0; 80 unsigned long iSeries_recal_tb = 0; 81 static unsigned long first_settimeofday = 1; 82 #endif 83 84 /* The decrementer counts down by 128 every 128ns on a 601. */ 85 #define DECREMENTER_COUNT_601 (1000000000 / HZ) 86 87 #define XSEC_PER_SEC (1024*1024) 88 89 #ifdef CONFIG_PPC64 90 #define SCALE_XSEC(xsec, max) (((xsec) * max) / XSEC_PER_SEC) 91 #else 92 /* compute ((xsec << 12) * max) >> 32 */ 93 #define SCALE_XSEC(xsec, max) mulhwu((xsec) << 12, max) 94 #endif 95 96 unsigned long tb_ticks_per_jiffy; 97 unsigned long tb_ticks_per_usec = 100; /* sane default */ 98 EXPORT_SYMBOL(tb_ticks_per_usec); 99 unsigned long tb_ticks_per_sec; 100 u64 tb_to_xs; 101 unsigned tb_to_us; 102 unsigned long processor_freq; 103 DEFINE_SPINLOCK(rtc_lock); 104 EXPORT_SYMBOL_GPL(rtc_lock); 105 106 u64 tb_to_ns_scale; 107 unsigned tb_to_ns_shift; 108 109 struct gettimeofday_struct do_gtod; 110 111 extern unsigned long wall_jiffies; 112 113 extern struct timezone sys_tz; 114 static long timezone_offset; 115 116 void ppc_adjtimex(void); 117 118 static unsigned adjusting_time = 0; 119 120 unsigned long ppc_proc_freq; 121 unsigned long ppc_tb_freq; 122 123 u64 tb_last_jiffy __cacheline_aligned_in_smp; 124 unsigned long tb_last_stamp; 125 126 /* 127 * Note that on ppc32 this only stores the bottom 32 bits of 128 * the timebase value, but that's enough to tell when a jiffy 129 * has passed. 130 */ 131 DEFINE_PER_CPU(unsigned long, last_jiffy); 132 133 void __delay(unsigned long loops) 134 { 135 unsigned long start; 136 int diff; 137 138 if (__USE_RTC()) { 139 start = get_rtcl(); 140 do { 141 /* the RTCL register wraps at 1000000000 */ 142 diff = get_rtcl() - start; 143 if (diff < 0) 144 diff += 1000000000; 145 } while (diff < loops); 146 } else { 147 start = get_tbl(); 148 while (get_tbl() - start < loops) 149 HMT_low(); 150 HMT_medium(); 151 } 152 } 153 EXPORT_SYMBOL(__delay); 154 155 void udelay(unsigned long usecs) 156 { 157 __delay(tb_ticks_per_usec * usecs); 158 } 159 EXPORT_SYMBOL(udelay); 160 161 static __inline__ void timer_check_rtc(void) 162 { 163 /* 164 * update the rtc when needed, this should be performed on the 165 * right fraction of a second. Half or full second ? 166 * Full second works on mk48t59 clocks, others need testing. 167 * Note that this update is basically only used through 168 * the adjtimex system calls. Setting the HW clock in 169 * any other way is a /dev/rtc and userland business. 170 * This is still wrong by -0.5/+1.5 jiffies because of the 171 * timer interrupt resolution and possible delay, but here we 172 * hit a quantization limit which can only be solved by higher 173 * resolution timers and decoupling time management from timer 174 * interrupts. This is also wrong on the clocks 175 * which require being written at the half second boundary. 176 * We should have an rtc call that only sets the minutes and 177 * seconds like on Intel to avoid problems with non UTC clocks. 178 */ 179 if (ppc_md.set_rtc_time && ntp_synced() && 180 xtime.tv_sec - last_rtc_update >= 659 && 181 abs((xtime.tv_nsec/1000) - (1000000-1000000/HZ)) < 500000/HZ && 182 jiffies - wall_jiffies == 1) { 183 struct rtc_time tm; 184 to_tm(xtime.tv_sec + 1 + timezone_offset, &tm); 185 tm.tm_year -= 1900; 186 tm.tm_mon -= 1; 187 if (ppc_md.set_rtc_time(&tm) == 0) 188 last_rtc_update = xtime.tv_sec + 1; 189 else 190 /* Try again one minute later */ 191 last_rtc_update += 60; 192 } 193 } 194 195 /* 196 * This version of gettimeofday has microsecond resolution. 197 */ 198 static inline void __do_gettimeofday(struct timeval *tv, u64 tb_val) 199 { 200 unsigned long sec, usec; 201 u64 tb_ticks, xsec; 202 struct gettimeofday_vars *temp_varp; 203 u64 temp_tb_to_xs, temp_stamp_xsec; 204 205 /* 206 * These calculations are faster (gets rid of divides) 207 * if done in units of 1/2^20 rather than microseconds. 208 * The conversion to microseconds at the end is done 209 * without a divide (and in fact, without a multiply) 210 */ 211 temp_varp = do_gtod.varp; 212 tb_ticks = tb_val - temp_varp->tb_orig_stamp; 213 temp_tb_to_xs = temp_varp->tb_to_xs; 214 temp_stamp_xsec = temp_varp->stamp_xsec; 215 xsec = temp_stamp_xsec + mulhdu(tb_ticks, temp_tb_to_xs); 216 sec = xsec / XSEC_PER_SEC; 217 usec = (unsigned long)xsec & (XSEC_PER_SEC - 1); 218 usec = SCALE_XSEC(usec, 1000000); 219 220 tv->tv_sec = sec; 221 tv->tv_usec = usec; 222 } 223 224 void do_gettimeofday(struct timeval *tv) 225 { 226 if (__USE_RTC()) { 227 /* do this the old way */ 228 unsigned long flags, seq; 229 unsigned int sec, nsec, usec, lost; 230 231 do { 232 seq = read_seqbegin_irqsave(&xtime_lock, flags); 233 sec = xtime.tv_sec; 234 nsec = xtime.tv_nsec + tb_ticks_since(tb_last_stamp); 235 lost = jiffies - wall_jiffies; 236 } while (read_seqretry_irqrestore(&xtime_lock, seq, flags)); 237 usec = nsec / 1000 + lost * (1000000 / HZ); 238 while (usec >= 1000000) { 239 usec -= 1000000; 240 ++sec; 241 } 242 tv->tv_sec = sec; 243 tv->tv_usec = usec; 244 return; 245 } 246 __do_gettimeofday(tv, get_tb()); 247 } 248 249 EXPORT_SYMBOL(do_gettimeofday); 250 251 /* Synchronize xtime with do_gettimeofday */ 252 253 static inline void timer_sync_xtime(unsigned long cur_tb) 254 { 255 #ifdef CONFIG_PPC64 256 /* why do we do this? */ 257 struct timeval my_tv; 258 259 __do_gettimeofday(&my_tv, cur_tb); 260 261 if (xtime.tv_sec <= my_tv.tv_sec) { 262 xtime.tv_sec = my_tv.tv_sec; 263 xtime.tv_nsec = my_tv.tv_usec * 1000; 264 } 265 #endif 266 } 267 268 /* 269 * There are two copies of tb_to_xs and stamp_xsec so that no 270 * lock is needed to access and use these values in 271 * do_gettimeofday. We alternate the copies and as long as a 272 * reasonable time elapses between changes, there will never 273 * be inconsistent values. ntpd has a minimum of one minute 274 * between updates. 275 */ 276 static inline void update_gtod(u64 new_tb_stamp, u64 new_stamp_xsec, 277 u64 new_tb_to_xs) 278 { 279 unsigned temp_idx; 280 struct gettimeofday_vars *temp_varp; 281 282 temp_idx = (do_gtod.var_idx == 0); 283 temp_varp = &do_gtod.vars[temp_idx]; 284 285 temp_varp->tb_to_xs = new_tb_to_xs; 286 temp_varp->tb_orig_stamp = new_tb_stamp; 287 temp_varp->stamp_xsec = new_stamp_xsec; 288 smp_mb(); 289 do_gtod.varp = temp_varp; 290 do_gtod.var_idx = temp_idx; 291 292 /* 293 * tb_update_count is used to allow the userspace gettimeofday code 294 * to assure itself that it sees a consistent view of the tb_to_xs and 295 * stamp_xsec variables. It reads the tb_update_count, then reads 296 * tb_to_xs and stamp_xsec and then reads tb_update_count again. If 297 * the two values of tb_update_count match and are even then the 298 * tb_to_xs and stamp_xsec values are consistent. If not, then it 299 * loops back and reads them again until this criteria is met. 300 */ 301 ++(vdso_data->tb_update_count); 302 smp_wmb(); 303 vdso_data->tb_orig_stamp = new_tb_stamp; 304 vdso_data->stamp_xsec = new_stamp_xsec; 305 vdso_data->tb_to_xs = new_tb_to_xs; 306 vdso_data->wtom_clock_sec = wall_to_monotonic.tv_sec; 307 vdso_data->wtom_clock_nsec = wall_to_monotonic.tv_nsec; 308 smp_wmb(); 309 ++(vdso_data->tb_update_count); 310 } 311 312 /* 313 * When the timebase - tb_orig_stamp gets too big, we do a manipulation 314 * between tb_orig_stamp and stamp_xsec. The goal here is to keep the 315 * difference tb - tb_orig_stamp small enough to always fit inside a 316 * 32 bits number. This is a requirement of our fast 32 bits userland 317 * implementation in the vdso. If we "miss" a call to this function 318 * (interrupt latency, CPU locked in a spinlock, ...) and we end up 319 * with a too big difference, then the vdso will fallback to calling 320 * the syscall 321 */ 322 static __inline__ void timer_recalc_offset(u64 cur_tb) 323 { 324 unsigned long offset; 325 u64 new_stamp_xsec; 326 327 if (__USE_RTC()) 328 return; 329 offset = cur_tb - do_gtod.varp->tb_orig_stamp; 330 if ((offset & 0x80000000u) == 0) 331 return; 332 new_stamp_xsec = do_gtod.varp->stamp_xsec 333 + mulhdu(offset, do_gtod.varp->tb_to_xs); 334 update_gtod(cur_tb, new_stamp_xsec, do_gtod.varp->tb_to_xs); 335 } 336 337 #ifdef CONFIG_SMP 338 unsigned long profile_pc(struct pt_regs *regs) 339 { 340 unsigned long pc = instruction_pointer(regs); 341 342 if (in_lock_functions(pc)) 343 return regs->link; 344 345 return pc; 346 } 347 EXPORT_SYMBOL(profile_pc); 348 #endif 349 350 #ifdef CONFIG_PPC_ISERIES 351 352 /* 353 * This function recalibrates the timebase based on the 49-bit time-of-day 354 * value in the Titan chip. The Titan is much more accurate than the value 355 * returned by the service processor for the timebase frequency. 356 */ 357 358 static void iSeries_tb_recal(void) 359 { 360 struct div_result divres; 361 unsigned long titan, tb; 362 tb = get_tb(); 363 titan = HvCallXm_loadTod(); 364 if ( iSeries_recal_titan ) { 365 unsigned long tb_ticks = tb - iSeries_recal_tb; 366 unsigned long titan_usec = (titan - iSeries_recal_titan) >> 12; 367 unsigned long new_tb_ticks_per_sec = (tb_ticks * USEC_PER_SEC)/titan_usec; 368 unsigned long new_tb_ticks_per_jiffy = (new_tb_ticks_per_sec+(HZ/2))/HZ; 369 long tick_diff = new_tb_ticks_per_jiffy - tb_ticks_per_jiffy; 370 char sign = '+'; 371 /* make sure tb_ticks_per_sec and tb_ticks_per_jiffy are consistent */ 372 new_tb_ticks_per_sec = new_tb_ticks_per_jiffy * HZ; 373 374 if ( tick_diff < 0 ) { 375 tick_diff = -tick_diff; 376 sign = '-'; 377 } 378 if ( tick_diff ) { 379 if ( tick_diff < tb_ticks_per_jiffy/25 ) { 380 printk( "Titan recalibrate: new tb_ticks_per_jiffy = %lu (%c%ld)\n", 381 new_tb_ticks_per_jiffy, sign, tick_diff ); 382 tb_ticks_per_jiffy = new_tb_ticks_per_jiffy; 383 tb_ticks_per_sec = new_tb_ticks_per_sec; 384 div128_by_32( XSEC_PER_SEC, 0, tb_ticks_per_sec, &divres ); 385 do_gtod.tb_ticks_per_sec = tb_ticks_per_sec; 386 tb_to_xs = divres.result_low; 387 do_gtod.varp->tb_to_xs = tb_to_xs; 388 vdso_data->tb_ticks_per_sec = tb_ticks_per_sec; 389 vdso_data->tb_to_xs = tb_to_xs; 390 } 391 else { 392 printk( "Titan recalibrate: FAILED (difference > 4 percent)\n" 393 " new tb_ticks_per_jiffy = %lu\n" 394 " old tb_ticks_per_jiffy = %lu\n", 395 new_tb_ticks_per_jiffy, tb_ticks_per_jiffy ); 396 } 397 } 398 } 399 iSeries_recal_titan = titan; 400 iSeries_recal_tb = tb; 401 } 402 #endif 403 404 /* 405 * For iSeries shared processors, we have to let the hypervisor 406 * set the hardware decrementer. We set a virtual decrementer 407 * in the lppaca and call the hypervisor if the virtual 408 * decrementer is less than the current value in the hardware 409 * decrementer. (almost always the new decrementer value will 410 * be greater than the current hardware decementer so the hypervisor 411 * call will not be needed) 412 */ 413 414 /* 415 * timer_interrupt - gets called when the decrementer overflows, 416 * with interrupts disabled. 417 */ 418 void timer_interrupt(struct pt_regs * regs) 419 { 420 int next_dec; 421 int cpu = smp_processor_id(); 422 unsigned long ticks; 423 424 #ifdef CONFIG_PPC32 425 if (atomic_read(&ppc_n_lost_interrupts) != 0) 426 do_IRQ(regs); 427 #endif 428 429 irq_enter(); 430 431 profile_tick(CPU_PROFILING, regs); 432 433 #ifdef CONFIG_PPC_ISERIES 434 get_paca()->lppaca.int_dword.fields.decr_int = 0; 435 #endif 436 437 while ((ticks = tb_ticks_since(per_cpu(last_jiffy, cpu))) 438 >= tb_ticks_per_jiffy) { 439 /* Update last_jiffy */ 440 per_cpu(last_jiffy, cpu) += tb_ticks_per_jiffy; 441 /* Handle RTCL overflow on 601 */ 442 if (__USE_RTC() && per_cpu(last_jiffy, cpu) >= 1000000000) 443 per_cpu(last_jiffy, cpu) -= 1000000000; 444 445 /* 446 * We cannot disable the decrementer, so in the period 447 * between this cpu's being marked offline in cpu_online_map 448 * and calling stop-self, it is taking timer interrupts. 449 * Avoid calling into the scheduler rebalancing code if this 450 * is the case. 451 */ 452 if (!cpu_is_offline(cpu)) 453 update_process_times(user_mode(regs)); 454 455 /* 456 * No need to check whether cpu is offline here; boot_cpuid 457 * should have been fixed up by now. 458 */ 459 if (cpu != boot_cpuid) 460 continue; 461 462 write_seqlock(&xtime_lock); 463 tb_last_jiffy += tb_ticks_per_jiffy; 464 tb_last_stamp = per_cpu(last_jiffy, cpu); 465 timer_recalc_offset(tb_last_jiffy); 466 do_timer(regs); 467 timer_sync_xtime(tb_last_jiffy); 468 timer_check_rtc(); 469 write_sequnlock(&xtime_lock); 470 if (adjusting_time && (time_adjust == 0)) 471 ppc_adjtimex(); 472 } 473 474 next_dec = tb_ticks_per_jiffy - ticks; 475 set_dec(next_dec); 476 477 #ifdef CONFIG_PPC_ISERIES 478 if (hvlpevent_is_pending()) 479 process_hvlpevents(regs); 480 #endif 481 482 #ifdef CONFIG_PPC64 483 /* collect purr register values often, for accurate calculations */ 484 if (firmware_has_feature(FW_FEATURE_SPLPAR)) { 485 struct cpu_usage *cu = &__get_cpu_var(cpu_usage_array); 486 cu->current_tb = mfspr(SPRN_PURR); 487 } 488 #endif 489 490 irq_exit(); 491 } 492 493 void wakeup_decrementer(void) 494 { 495 int i; 496 497 set_dec(tb_ticks_per_jiffy); 498 /* 499 * We don't expect this to be called on a machine with a 601, 500 * so using get_tbl is fine. 501 */ 502 tb_last_stamp = tb_last_jiffy = get_tb(); 503 for_each_cpu(i) 504 per_cpu(last_jiffy, i) = tb_last_stamp; 505 } 506 507 #ifdef CONFIG_SMP 508 void __init smp_space_timers(unsigned int max_cpus) 509 { 510 int i; 511 unsigned long offset = tb_ticks_per_jiffy / max_cpus; 512 unsigned long previous_tb = per_cpu(last_jiffy, boot_cpuid); 513 514 /* make sure tb > per_cpu(last_jiffy, cpu) for all cpus always */ 515 previous_tb -= tb_ticks_per_jiffy; 516 for_each_cpu(i) { 517 if (i != boot_cpuid) { 518 previous_tb += offset; 519 per_cpu(last_jiffy, i) = previous_tb; 520 } 521 } 522 } 523 #endif 524 525 /* 526 * Scheduler clock - returns current time in nanosec units. 527 * 528 * Note: mulhdu(a, b) (multiply high double unsigned) returns 529 * the high 64 bits of a * b, i.e. (a * b) >> 64, where a and b 530 * are 64-bit unsigned numbers. 531 */ 532 unsigned long long sched_clock(void) 533 { 534 if (__USE_RTC()) 535 return get_rtc(); 536 return mulhdu(get_tb(), tb_to_ns_scale) << tb_to_ns_shift; 537 } 538 539 int do_settimeofday(struct timespec *tv) 540 { 541 time_t wtm_sec, new_sec = tv->tv_sec; 542 long wtm_nsec, new_nsec = tv->tv_nsec; 543 unsigned long flags; 544 long int tb_delta; 545 u64 new_xsec, tb_delta_xs; 546 547 if ((unsigned long)tv->tv_nsec >= NSEC_PER_SEC) 548 return -EINVAL; 549 550 write_seqlock_irqsave(&xtime_lock, flags); 551 552 /* 553 * Updating the RTC is not the job of this code. If the time is 554 * stepped under NTP, the RTC will be updated after STA_UNSYNC 555 * is cleared. Tools like clock/hwclock either copy the RTC 556 * to the system time, in which case there is no point in writing 557 * to the RTC again, or write to the RTC but then they don't call 558 * settimeofday to perform this operation. 559 */ 560 #ifdef CONFIG_PPC_ISERIES 561 if (first_settimeofday) { 562 iSeries_tb_recal(); 563 first_settimeofday = 0; 564 } 565 #endif 566 tb_delta = tb_ticks_since(tb_last_stamp); 567 tb_delta += (jiffies - wall_jiffies) * tb_ticks_per_jiffy; 568 tb_delta_xs = mulhdu(tb_delta, do_gtod.varp->tb_to_xs); 569 570 wtm_sec = wall_to_monotonic.tv_sec + (xtime.tv_sec - new_sec); 571 wtm_nsec = wall_to_monotonic.tv_nsec + (xtime.tv_nsec - new_nsec); 572 573 set_normalized_timespec(&xtime, new_sec, new_nsec); 574 set_normalized_timespec(&wall_to_monotonic, wtm_sec, wtm_nsec); 575 576 /* In case of a large backwards jump in time with NTP, we want the 577 * clock to be updated as soon as the PLL is again in lock. 578 */ 579 last_rtc_update = new_sec - 658; 580 581 ntp_clear(); 582 583 new_xsec = 0; 584 if (new_nsec != 0) { 585 new_xsec = (u64)new_nsec * XSEC_PER_SEC; 586 do_div(new_xsec, NSEC_PER_SEC); 587 } 588 new_xsec += (u64)new_sec * XSEC_PER_SEC - tb_delta_xs; 589 update_gtod(tb_last_jiffy, new_xsec, do_gtod.varp->tb_to_xs); 590 591 vdso_data->tz_minuteswest = sys_tz.tz_minuteswest; 592 vdso_data->tz_dsttime = sys_tz.tz_dsttime; 593 594 write_sequnlock_irqrestore(&xtime_lock, flags); 595 clock_was_set(); 596 return 0; 597 } 598 599 EXPORT_SYMBOL(do_settimeofday); 600 601 void __init generic_calibrate_decr(void) 602 { 603 struct device_node *cpu; 604 unsigned int *fp; 605 int node_found; 606 607 /* 608 * The cpu node should have a timebase-frequency property 609 * to tell us the rate at which the decrementer counts. 610 */ 611 cpu = of_find_node_by_type(NULL, "cpu"); 612 613 ppc_tb_freq = DEFAULT_TB_FREQ; /* hardcoded default */ 614 node_found = 0; 615 if (cpu != 0) { 616 fp = (unsigned int *)get_property(cpu, "timebase-frequency", 617 NULL); 618 if (fp != 0) { 619 node_found = 1; 620 ppc_tb_freq = *fp; 621 } 622 } 623 if (!node_found) 624 printk(KERN_ERR "WARNING: Estimating decrementer frequency " 625 "(not found)\n"); 626 627 ppc_proc_freq = DEFAULT_PROC_FREQ; 628 node_found = 0; 629 if (cpu != 0) { 630 fp = (unsigned int *)get_property(cpu, "clock-frequency", 631 NULL); 632 if (fp != 0) { 633 node_found = 1; 634 ppc_proc_freq = *fp; 635 } 636 } 637 #ifdef CONFIG_BOOKE 638 /* Set the time base to zero */ 639 mtspr(SPRN_TBWL, 0); 640 mtspr(SPRN_TBWU, 0); 641 642 /* Clear any pending timer interrupts */ 643 mtspr(SPRN_TSR, TSR_ENW | TSR_WIS | TSR_DIS | TSR_FIS); 644 645 /* Enable decrementer interrupt */ 646 mtspr(SPRN_TCR, TCR_DIE); 647 #endif 648 if (!node_found) 649 printk(KERN_ERR "WARNING: Estimating processor frequency " 650 "(not found)\n"); 651 652 of_node_put(cpu); 653 } 654 655 unsigned long get_boot_time(void) 656 { 657 struct rtc_time tm; 658 659 if (ppc_md.get_boot_time) 660 return ppc_md.get_boot_time(); 661 if (!ppc_md.get_rtc_time) 662 return 0; 663 ppc_md.get_rtc_time(&tm); 664 return mktime(tm.tm_year+1900, tm.tm_mon+1, tm.tm_mday, 665 tm.tm_hour, tm.tm_min, tm.tm_sec); 666 } 667 668 /* This function is only called on the boot processor */ 669 void __init time_init(void) 670 { 671 unsigned long flags; 672 unsigned long tm = 0; 673 struct div_result res; 674 u64 scale; 675 unsigned shift; 676 677 if (ppc_md.time_init != NULL) 678 timezone_offset = ppc_md.time_init(); 679 680 if (__USE_RTC()) { 681 /* 601 processor: dec counts down by 128 every 128ns */ 682 ppc_tb_freq = 1000000000; 683 tb_last_stamp = get_rtcl(); 684 tb_last_jiffy = tb_last_stamp; 685 } else { 686 /* Normal PowerPC with timebase register */ 687 ppc_md.calibrate_decr(); 688 printk(KERN_INFO "time_init: decrementer frequency = %lu.%.6lu MHz\n", 689 ppc_tb_freq / 1000000, ppc_tb_freq % 1000000); 690 printk(KERN_INFO "time_init: processor frequency = %lu.%.6lu MHz\n", 691 ppc_proc_freq / 1000000, ppc_proc_freq % 1000000); 692 tb_last_stamp = tb_last_jiffy = get_tb(); 693 } 694 695 tb_ticks_per_jiffy = ppc_tb_freq / HZ; 696 tb_ticks_per_sec = tb_ticks_per_jiffy * HZ; 697 tb_ticks_per_usec = ppc_tb_freq / 1000000; 698 tb_to_us = mulhwu_scale_factor(ppc_tb_freq, 1000000); 699 div128_by_32(1024*1024, 0, tb_ticks_per_sec, &res); 700 tb_to_xs = res.result_low; 701 702 /* 703 * Compute scale factor for sched_clock. 704 * The calibrate_decr() function has set tb_ticks_per_sec, 705 * which is the timebase frequency. 706 * We compute 1e9 * 2^64 / tb_ticks_per_sec and interpret 707 * the 128-bit result as a 64.64 fixed-point number. 708 * We then shift that number right until it is less than 1.0, 709 * giving us the scale factor and shift count to use in 710 * sched_clock(). 711 */ 712 div128_by_32(1000000000, 0, tb_ticks_per_sec, &res); 713 scale = res.result_low; 714 for (shift = 0; res.result_high != 0; ++shift) { 715 scale = (scale >> 1) | (res.result_high << 63); 716 res.result_high >>= 1; 717 } 718 tb_to_ns_scale = scale; 719 tb_to_ns_shift = shift; 720 721 #ifdef CONFIG_PPC_ISERIES 722 if (!piranha_simulator) 723 #endif 724 tm = get_boot_time(); 725 726 write_seqlock_irqsave(&xtime_lock, flags); 727 xtime.tv_sec = tm; 728 xtime.tv_nsec = 0; 729 do_gtod.varp = &do_gtod.vars[0]; 730 do_gtod.var_idx = 0; 731 do_gtod.varp->tb_orig_stamp = tb_last_jiffy; 732 __get_cpu_var(last_jiffy) = tb_last_stamp; 733 do_gtod.varp->stamp_xsec = (u64) xtime.tv_sec * XSEC_PER_SEC; 734 do_gtod.tb_ticks_per_sec = tb_ticks_per_sec; 735 do_gtod.varp->tb_to_xs = tb_to_xs; 736 do_gtod.tb_to_us = tb_to_us; 737 738 vdso_data->tb_orig_stamp = tb_last_jiffy; 739 vdso_data->tb_update_count = 0; 740 vdso_data->tb_ticks_per_sec = tb_ticks_per_sec; 741 vdso_data->stamp_xsec = xtime.tv_sec * XSEC_PER_SEC; 742 vdso_data->tb_to_xs = tb_to_xs; 743 744 time_freq = 0; 745 746 /* If platform provided a timezone (pmac), we correct the time */ 747 if (timezone_offset) { 748 sys_tz.tz_minuteswest = -timezone_offset / 60; 749 sys_tz.tz_dsttime = 0; 750 xtime.tv_sec -= timezone_offset; 751 } 752 753 last_rtc_update = xtime.tv_sec; 754 set_normalized_timespec(&wall_to_monotonic, 755 -xtime.tv_sec, -xtime.tv_nsec); 756 write_sequnlock_irqrestore(&xtime_lock, flags); 757 758 /* Not exact, but the timer interrupt takes care of this */ 759 set_dec(tb_ticks_per_jiffy); 760 } 761 762 /* 763 * After adjtimex is called, adjust the conversion of tb ticks 764 * to microseconds to keep do_gettimeofday synchronized 765 * with ntpd. 766 * 767 * Use the time_adjust, time_freq and time_offset computed by adjtimex to 768 * adjust the frequency. 769 */ 770 771 /* #define DEBUG_PPC_ADJTIMEX 1 */ 772 773 void ppc_adjtimex(void) 774 { 775 #ifdef CONFIG_PPC64 776 unsigned long den, new_tb_ticks_per_sec, tb_ticks, old_xsec, 777 new_tb_to_xs, new_xsec, new_stamp_xsec; 778 unsigned long tb_ticks_per_sec_delta; 779 long delta_freq, ltemp; 780 struct div_result divres; 781 unsigned long flags; 782 long singleshot_ppm = 0; 783 784 /* 785 * Compute parts per million frequency adjustment to 786 * accomplish the time adjustment implied by time_offset to be 787 * applied over the elapsed time indicated by time_constant. 788 * Use SHIFT_USEC to get it into the same units as 789 * time_freq. 790 */ 791 if ( time_offset < 0 ) { 792 ltemp = -time_offset; 793 ltemp <<= SHIFT_USEC - SHIFT_UPDATE; 794 ltemp >>= SHIFT_KG + time_constant; 795 ltemp = -ltemp; 796 } else { 797 ltemp = time_offset; 798 ltemp <<= SHIFT_USEC - SHIFT_UPDATE; 799 ltemp >>= SHIFT_KG + time_constant; 800 } 801 802 /* If there is a single shot time adjustment in progress */ 803 if ( time_adjust ) { 804 #ifdef DEBUG_PPC_ADJTIMEX 805 printk("ppc_adjtimex: "); 806 if ( adjusting_time == 0 ) 807 printk("starting "); 808 printk("single shot time_adjust = %ld\n", time_adjust); 809 #endif 810 811 adjusting_time = 1; 812 813 /* 814 * Compute parts per million frequency adjustment 815 * to match time_adjust 816 */ 817 singleshot_ppm = tickadj * HZ; 818 /* 819 * The adjustment should be tickadj*HZ to match the code in 820 * linux/kernel/timer.c, but experiments show that this is too 821 * large. 3/4 of tickadj*HZ seems about right 822 */ 823 singleshot_ppm -= singleshot_ppm / 4; 824 /* Use SHIFT_USEC to get it into the same units as time_freq */ 825 singleshot_ppm <<= SHIFT_USEC; 826 if ( time_adjust < 0 ) 827 singleshot_ppm = -singleshot_ppm; 828 } 829 else { 830 #ifdef DEBUG_PPC_ADJTIMEX 831 if ( adjusting_time ) 832 printk("ppc_adjtimex: ending single shot time_adjust\n"); 833 #endif 834 adjusting_time = 0; 835 } 836 837 /* Add up all of the frequency adjustments */ 838 delta_freq = time_freq + ltemp + singleshot_ppm; 839 840 /* 841 * Compute a new value for tb_ticks_per_sec based on 842 * the frequency adjustment 843 */ 844 den = 1000000 * (1 << (SHIFT_USEC - 8)); 845 if ( delta_freq < 0 ) { 846 tb_ticks_per_sec_delta = ( tb_ticks_per_sec * ( (-delta_freq) >> (SHIFT_USEC - 8))) / den; 847 new_tb_ticks_per_sec = tb_ticks_per_sec + tb_ticks_per_sec_delta; 848 } 849 else { 850 tb_ticks_per_sec_delta = ( tb_ticks_per_sec * ( delta_freq >> (SHIFT_USEC - 8))) / den; 851 new_tb_ticks_per_sec = tb_ticks_per_sec - tb_ticks_per_sec_delta; 852 } 853 854 #ifdef DEBUG_PPC_ADJTIMEX 855 printk("ppc_adjtimex: ltemp = %ld, time_freq = %ld, singleshot_ppm = %ld\n", ltemp, time_freq, singleshot_ppm); 856 printk("ppc_adjtimex: tb_ticks_per_sec - base = %ld new = %ld\n", tb_ticks_per_sec, new_tb_ticks_per_sec); 857 #endif 858 859 /* 860 * Compute a new value of tb_to_xs (used to convert tb to 861 * microseconds) and a new value of stamp_xsec which is the 862 * time (in 1/2^20 second units) corresponding to 863 * tb_orig_stamp. This new value of stamp_xsec compensates 864 * for the change in frequency (implied by the new tb_to_xs) 865 * which guarantees that the current time remains the same. 866 */ 867 write_seqlock_irqsave( &xtime_lock, flags ); 868 tb_ticks = get_tb() - do_gtod.varp->tb_orig_stamp; 869 div128_by_32(1024*1024, 0, new_tb_ticks_per_sec, &divres); 870 new_tb_to_xs = divres.result_low; 871 new_xsec = mulhdu(tb_ticks, new_tb_to_xs); 872 873 old_xsec = mulhdu(tb_ticks, do_gtod.varp->tb_to_xs); 874 new_stamp_xsec = do_gtod.varp->stamp_xsec + old_xsec - new_xsec; 875 876 update_gtod(do_gtod.varp->tb_orig_stamp, new_stamp_xsec, new_tb_to_xs); 877 878 write_sequnlock_irqrestore( &xtime_lock, flags ); 879 #endif /* CONFIG_PPC64 */ 880 } 881 882 883 #define FEBRUARY 2 884 #define STARTOFTIME 1970 885 #define SECDAY 86400L 886 #define SECYR (SECDAY * 365) 887 #define leapyear(year) ((year) % 4 == 0 && \ 888 ((year) % 100 != 0 || (year) % 400 == 0)) 889 #define days_in_year(a) (leapyear(a) ? 366 : 365) 890 #define days_in_month(a) (month_days[(a) - 1]) 891 892 static int month_days[12] = { 893 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 894 }; 895 896 /* 897 * This only works for the Gregorian calendar - i.e. after 1752 (in the UK) 898 */ 899 void GregorianDay(struct rtc_time * tm) 900 { 901 int leapsToDate; 902 int lastYear; 903 int day; 904 int MonthOffset[] = { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 }; 905 906 lastYear = tm->tm_year - 1; 907 908 /* 909 * Number of leap corrections to apply up to end of last year 910 */ 911 leapsToDate = lastYear / 4 - lastYear / 100 + lastYear / 400; 912 913 /* 914 * This year is a leap year if it is divisible by 4 except when it is 915 * divisible by 100 unless it is divisible by 400 916 * 917 * e.g. 1904 was a leap year, 1900 was not, 1996 is, and 2000 was 918 */ 919 day = tm->tm_mon > 2 && leapyear(tm->tm_year); 920 921 day += lastYear*365 + leapsToDate + MonthOffset[tm->tm_mon-1] + 922 tm->tm_mday; 923 924 tm->tm_wday = day % 7; 925 } 926 927 void to_tm(int tim, struct rtc_time * tm) 928 { 929 register int i; 930 register long hms, day; 931 932 day = tim / SECDAY; 933 hms = tim % SECDAY; 934 935 /* Hours, minutes, seconds are easy */ 936 tm->tm_hour = hms / 3600; 937 tm->tm_min = (hms % 3600) / 60; 938 tm->tm_sec = (hms % 3600) % 60; 939 940 /* Number of years in days */ 941 for (i = STARTOFTIME; day >= days_in_year(i); i++) 942 day -= days_in_year(i); 943 tm->tm_year = i; 944 945 /* Number of months in days left */ 946 if (leapyear(tm->tm_year)) 947 days_in_month(FEBRUARY) = 29; 948 for (i = 1; day >= days_in_month(i); i++) 949 day -= days_in_month(i); 950 days_in_month(FEBRUARY) = 28; 951 tm->tm_mon = i; 952 953 /* Days are what is left over (+1) from all that. */ 954 tm->tm_mday = day + 1; 955 956 /* 957 * Determine the day of week 958 */ 959 GregorianDay(tm); 960 } 961 962 /* Auxiliary function to compute scaling factors */ 963 /* Actually the choice of a timebase running at 1/4 the of the bus 964 * frequency giving resolution of a few tens of nanoseconds is quite nice. 965 * It makes this computation very precise (27-28 bits typically) which 966 * is optimistic considering the stability of most processor clock 967 * oscillators and the precision with which the timebase frequency 968 * is measured but does not harm. 969 */ 970 unsigned mulhwu_scale_factor(unsigned inscale, unsigned outscale) 971 { 972 unsigned mlt=0, tmp, err; 973 /* No concern for performance, it's done once: use a stupid 974 * but safe and compact method to find the multiplier. 975 */ 976 977 for (tmp = 1U<<31; tmp != 0; tmp >>= 1) { 978 if (mulhwu(inscale, mlt|tmp) < outscale) 979 mlt |= tmp; 980 } 981 982 /* We might still be off by 1 for the best approximation. 983 * A side effect of this is that if outscale is too large 984 * the returned value will be zero. 985 * Many corner cases have been checked and seem to work, 986 * some might have been forgotten in the test however. 987 */ 988 989 err = inscale * (mlt+1); 990 if (err <= inscale/2) 991 mlt++; 992 return mlt; 993 } 994 995 /* 996 * Divide a 128-bit dividend by a 32-bit divisor, leaving a 128 bit 997 * result. 998 */ 999 void div128_by_32(u64 dividend_high, u64 dividend_low, 1000 unsigned divisor, struct div_result *dr) 1001 { 1002 unsigned long a, b, c, d; 1003 unsigned long w, x, y, z; 1004 u64 ra, rb, rc; 1005 1006 a = dividend_high >> 32; 1007 b = dividend_high & 0xffffffff; 1008 c = dividend_low >> 32; 1009 d = dividend_low & 0xffffffff; 1010 1011 w = a / divisor; 1012 ra = ((u64)(a - (w * divisor)) << 32) + b; 1013 1014 rb = ((u64) do_div(ra, divisor) << 32) + c; 1015 x = ra; 1016 1017 rc = ((u64) do_div(rb, divisor) << 32) + d; 1018 y = rb; 1019 1020 do_div(rc, divisor); 1021 z = rc; 1022 1023 dr->result_high = ((u64)w << 32) + x; 1024 dr->result_low = ((u64)y << 32) + z; 1025 1026 } 1027