arch/x86/kernel/tsc.c

   1 #include <linux/kernel.h>
   2 #include <linux/sched.h>
   3 #include <linux/init.h>
   4 #include <linux/module.h>
   5 #include <linux/timer.h>
   6 #include <linux/acpi_pmtmr.h>
   7 #include <linux/cpufreq.h>
   8 #include <linux/dmi.h>
   9 #include <linux/delay.h>
  10 #include <linux/clocksource.h>
  11 #include <linux/percpu.h>
  12
  13 #include <asm/hpet.h>
  14 #include <asm/timer.h>
  15 #include <asm/vgtod.h>
  16 #include <asm/time.h>
  17 #include <asm/delay.h>
  18
  19 unsigned int cpu_khz;           /* TSC clocks / usec, not used here */
  20 EXPORT_SYMBOL(cpu_khz);
  21 unsigned int tsc_khz;
  22 EXPORT_SYMBOL(tsc_khz);
  23
  24 /*
  25  * TSC can be unstable due to cpufreq or due to unsynced TSCs
  26  */
  27 static int tsc_unstable;
  28
  29 /* native_sched_clock() is called before tsc_init(), so
  30    we must start with the TSC soft disabled to prevent
  31    erroneous rdtsc usage on !cpu_has_tsc processors */
  32 static int tsc_disabled = -1;
  33
  34 /*
  35  * Scheduler clock - returns current time in nanosec units.
  36  */
  37 u64 native_sched_clock(void)
  38 {
  39         u64 this_offset;
  40
  41         /*
  42          * Fall back to jiffies if there's no TSC available:
  43          * ( But note that we still use it if the TSC is marked
  44          *   unstable. We do this because unlike Time Of Day,
  45          *   the scheduler clock tolerates small errors and it's
  46          *   very important for it to be as fast as the platform
  47          *   can achive it. )
  48          */
  49         if (unlikely(tsc_disabled)) {
  50                 /* No locking but a rare wrong value is not a big deal: */
  51                 return (jiffies_64 - INITIAL_JIFFIES) * (1000000000 / HZ);
  52         }
  53
  54         /* read the Time Stamp Counter: */
  55         rdtscll(this_offset);
  56
  57         /* return the value in ns */
  58         return cycles_2_ns(this_offset);
  59 }
  60
  61 /* We need to define a real function for sched_clock, to override the
  62    weak default version */
  63 #ifdef CONFIG_PARAVIRT
  64 unsigned long long sched_clock(void)
  65 {
  66         return paravirt_sched_clock();
  67 }
  68 #else
  69 unsigned long long
  70 sched_clock(void) __attribute__((alias("native_sched_clock")));
  71 #endif
  72
  73 int check_tsc_unstable(void)
  74 {
  75         return tsc_unstable;
  76 }
  77 EXPORT_SYMBOL_GPL(check_tsc_unstable);
  78
  79 #ifdef CONFIG_X86_TSC
  80 int __init notsc_setup(char *str)
  81 {
  82         printk(KERN_WARNING "notsc: Kernel compiled with CONFIG_X86_TSC, "
  83                         "cannot disable TSC completely.\n");
  84         tsc_disabled = 1;
  85         return 1;
  86 }
  87 #else
  88 /*
  89  * disable flag for tsc. Takes effect by clearing the TSC cpu flag
  90  * in cpu/common.c
  91  */
  92 int __init notsc_setup(char *str)
  93 {
  94         setup_clear_cpu_cap(X86_FEATURE_TSC);
  95         return 1;
  96 }
  97 #endif
  98
  99 __setup("notsc", notsc_setup);
 100
 101 #define MAX_RETRIES     5
 102 #define SMI_TRESHOLD    50000
 103
 104 /*
 105  * Read TSC and the reference counters. Take care of SMI disturbance
 106  */
 107 static u64 __init tsc_read_refs(u64 *pm, u64 *hpet)
 108 {
 109         u64 t1, t2;
 110         int i;
 111
 112         for (i = 0; i < MAX_RETRIES; i++) {
 113                 t1 = get_cycles();
 114                 if (hpet)
 115                         *hpet = hpet_readl(HPET_COUNTER) & 0xFFFFFFFF;
 116                 else
 117                         *pm = acpi_pm_read_early();
 118                 t2 = get_cycles();
 119                 if ((t2 - t1) < SMI_TRESHOLD)
 120                         return t2;
 121         }
 122         return ULLONG_MAX;
 123 }
 124
 125 /**
 126  * native_calibrate_tsc - calibrate the tsc on boot
 127  */
 128 unsigned long native_calibrate_tsc(void)
 129 {
 130         unsigned long flags;
 131         u64 tsc1, tsc2, tr1, tr2, delta, pm1, pm2, hpet1, hpet2;
 132         int hpet = is_hpet_enabled();
 133         unsigned int tsc_khz_val = 0;
 134
 135         local_irq_save(flags);
 136
 137         tsc1 = tsc_read_refs(&pm1, hpet ? &hpet1 : NULL);
 138
 139         outb((inb(0x61) & ~0x02) | 0x01, 0x61);
 140
 141         outb(0xb0, 0x43);
 142         outb((CLOCK_TICK_RATE / (1000 / 50)) & 0xff, 0x42);
 143         outb((CLOCK_TICK_RATE / (1000 / 50)) >> 8, 0x42);
 144         tr1 = get_cycles();
 145         while ((inb(0x61) & 0x20) == 0);
 146         tr2 = get_cycles();
 147
 148         tsc2 = tsc_read_refs(&pm2, hpet ? &hpet2 : NULL);
 149
 150         local_irq_restore(flags);
 151
 152         /*
 153          * Preset the result with the raw and inaccurate PIT
 154          * calibration value
 155          */
 156         delta = (tr2 - tr1);
 157         do_div(delta, 50);
 158         tsc_khz_val = delta;
 159
 160         /* hpet or pmtimer available ? */
 161         if (!hpet && !pm1 && !pm2) {
 162                 printk(KERN_INFO "TSC calibrated against PIT\n");
 163                 goto out;
 164         }
 165
 166         /* Check, whether the sampling was disturbed by an SMI */
 167         if (tsc1 == ULLONG_MAX || tsc2 == ULLONG_MAX) {
 168                 printk(KERN_WARNING "TSC calibration disturbed by SMI, "
 169                                 "using PIT calibration result\n");
 170                 goto out;
 171         }
 172
 173         tsc2 = (tsc2 - tsc1) * 1000000LL;
 174
 175         if (hpet) {
 176                 printk(KERN_INFO "TSC calibrated against HPET\n");
 177                 if (hpet2 < hpet1)
 178                         hpet2 += 0x100000000ULL;
 179                 hpet2 -= hpet1;
 180                 tsc1 = ((u64)hpet2 * hpet_readl(HPET_PERIOD));
 181                 do_div(tsc1, 1000000);
 182         } else {
 183                 printk(KERN_INFO "TSC calibrated against PM_TIMER\n");
 184                 if (pm2 < pm1)
 185                         pm2 += (u64)ACPI_PM_OVRRUN;
 186                 pm2 -= pm1;
 187                 tsc1 = pm2 * 1000000000LL;
 188                 do_div(tsc1, PMTMR_TICKS_PER_SEC);
 189         }
 190
 191         do_div(tsc2, tsc1);
 192         tsc_khz_val = tsc2;
 193
 194 out:
 195         return tsc_khz_val;
 196 }
 197
 198
 199 #ifdef CONFIG_X86_32
 200 /* Only called from the Powernow K7 cpu freq driver */
 201 int recalibrate_cpu_khz(void)
 202 {
 203 #ifndef CONFIG_SMP
 204         unsigned long cpu_khz_old = cpu_khz;
 205
 206         if (cpu_has_tsc) {
 207                 tsc_khz = calibrate_tsc();
 208                 cpu_khz = tsc_khz;
 209                 cpu_data(0).loops_per_jiffy =
 210                         cpufreq_scale(cpu_data(0).loops_per_jiffy,
 211                                         cpu_khz_old, cpu_khz);
 212                 return 0;
 213         } else
 214                 return -ENODEV;
 215 #else
 216         return -ENODEV;
 217 #endif
 218 }
 219
 220 EXPORT_SYMBOL(recalibrate_cpu_khz);
 221
 222 #endif /* CONFIG_X86_32 */
 223
 224 /* Accelerators for sched_clock()
 225  * convert from cycles(64bits) => nanoseconds (64bits)
 226  *  basic equation:
 227  *              ns = cycles / (freq / ns_per_sec)
 228  *              ns = cycles * (ns_per_sec / freq)
 229  *              ns = cycles * (10^9 / (cpu_khz * 10^3))
 230  *              ns = cycles * (10^6 / cpu_khz)
 231  *
 232  *      Then we use scaling math (suggested by george@mvista.com) to get:
 233  *              ns = cycles * (10^6 * SC / cpu_khz) / SC
 234  *              ns = cycles * cyc2ns_scale / SC
 235  *
 236  *      And since SC is a constant power of two, we can convert the div
 237  *  into a shift.
 238  *
 239  *  We can use khz divisor instead of mhz to keep a better precision, since
 240  *  cyc2ns_scale is limited to 10^6 * 2^10, which fits in 32 bits.
 241  *  (mathieu.desnoyers@polymtl.ca)
 242  *
 243  *                      -johnstul@us.ibm.com "math is hard, lets go shopping!"
 244  */
 245
 246 DEFINE_PER_CPU(unsigned long, cyc2ns);
 247
 248 static void set_cyc2ns_scale(unsigned long cpu_khz, int cpu)
 249 {
 250         unsigned long long tsc_now, ns_now;
 251         unsigned long flags, *scale;
 252
 253         local_irq_save(flags);
 254         sched_clock_idle_sleep_event();
 255
 256         scale = &per_cpu(cyc2ns, cpu);
 257
 258         rdtscll(tsc_now);
 259         ns_now = __cycles_2_ns(tsc_now);
 260
 261         if (cpu_khz)
 262                 *scale = (NSEC_PER_MSEC << CYC2NS_SCALE_FACTOR)/cpu_khz;
 263
 264         sched_clock_idle_wakeup_event(0);
 265         local_irq_restore(flags);
 266 }
 267
 268 #ifdef CONFIG_CPU_FREQ
 269
 270 /* Frequency scaling support. Adjust the TSC based timer when the cpu frequency
 271  * changes.
 272  *
 273  * RED-PEN: On SMP we assume all CPUs run with the same frequency.  It's
 274  * not that important because current Opteron setups do not support
 275  * scaling on SMP anyroads.
 276  *
 277  * Should fix up last_tsc too. Currently gettimeofday in the
 278  * first tick after the change will be slightly wrong.
 279  */
 280
 281 static unsigned int  ref_freq;
 282 static unsigned long loops_per_jiffy_ref;
 283 static unsigned long tsc_khz_ref;
 284
 285 static int time_cpufreq_notifier(struct notifier_block *nb, unsigned long val,
 286                                 void *data)
 287 {
 288         struct cpufreq_freqs *freq = data;
 289         unsigned long *lpj, dummy;
 290
 291         if (cpu_has(&cpu_data(freq->cpu), X86_FEATURE_CONSTANT_TSC))
 292                 return 0;
 293
 294         lpj = &dummy;
 295         if (!(freq->flags & CPUFREQ_CONST_LOOPS))
 296 #ifdef CONFIG_SMP
 297                 lpj = &cpu_data(freq->cpu).loops_per_jiffy;
 298 #else
 299         lpj = &boot_cpu_data.loops_per_jiffy;
 300 #endif
 301
 302         if (!ref_freq) {
 303                 ref_freq = freq->old;
 304                 loops_per_jiffy_ref = *lpj;
 305                 tsc_khz_ref = tsc_khz;
 306         }
 307         if ((val == CPUFREQ_PRECHANGE  && freq->old < freq->new) ||
 308                         (val == CPUFREQ_POSTCHANGE && freq->old > freq->new) ||
 309                         (val == CPUFREQ_RESUMECHANGE)) {
 310                 *lpj =  cpufreq_scale(loops_per_jiffy_ref, ref_freq, freq->new);
 311
 312                 tsc_khz = cpufreq_scale(tsc_khz_ref, ref_freq, freq->new);
 313                 if (!(freq->flags & CPUFREQ_CONST_LOOPS))
 314                         mark_tsc_unstable("cpufreq changes");
 315         }
 316
 317         set_cyc2ns_scale(tsc_khz_ref, freq->cpu);
 318
 319         return 0;
 320 }
 321
 322 static struct notifier_block time_cpufreq_notifier_block = {
 323         .notifier_call  = time_cpufreq_notifier
 324 };
 325
 326 static int __init cpufreq_tsc(void)
 327 {
 328         cpufreq_register_notifier(&time_cpufreq_notifier_block,
 329                                 CPUFREQ_TRANSITION_NOTIFIER);
 330         return 0;
 331 }
 332
 333 core_initcall(cpufreq_tsc);
 334
 335 #endif /* CONFIG_CPU_FREQ */
 336
 337 /* clocksource code */
 338
 339 static struct clocksource clocksource_tsc;
 340
 341 /*
 342  * We compare the TSC to the cycle_last value in the clocksource
 343  * structure to avoid a nasty time-warp. This can be observed in a
 344  * very small window right after one CPU updated cycle_last under
 345  * xtime/vsyscall_gtod lock and the other CPU reads a TSC value which
 346  * is smaller than the cycle_last reference value due to a TSC which
 347  * is slighty behind. This delta is nowhere else observable, but in
 348  * that case it results in a forward time jump in the range of hours
 349  * due to the unsigned delta calculation of the time keeping core
 350  * code, which is necessary to support wrapping clocksources like pm
 351  * timer.
 352  */
 353 static cycle_t read_tsc(void)
 354 {
 355         cycle_t ret = (cycle_t)get_cycles();
 356
 357         return ret >= clocksource_tsc.cycle_last ?
 358                 ret : clocksource_tsc.cycle_last;
 359 }
 360
 361 static cycle_t __vsyscall_fn vread_tsc(void)
 362 {
 363         cycle_t ret = (cycle_t)vget_cycles();
 364
 365         return ret >= __vsyscall_gtod_data.clock.cycle_last ?
 366                 ret : __vsyscall_gtod_data.clock.cycle_last;
 367 }
 368
 369 static struct clocksource clocksource_tsc = {
 370         .name                   = "tsc",
 371         .rating                 = 300,
 372         .read                   = read_tsc,
 373         .mask                   = CLOCKSOURCE_MASK(64),
 374         .shift                  = 22,
 375         .flags                  = CLOCK_SOURCE_IS_CONTINUOUS |
 376                                   CLOCK_SOURCE_MUST_VERIFY,
 377 #ifdef CONFIG_X86_64
 378         .vread                  = vread_tsc,
 379 #endif
 380 };
 381
 382 void mark_tsc_unstable(char *reason)
 383 {
 384         if (!tsc_unstable) {
 385                 tsc_unstable = 1;
 386                 printk("Marking TSC unstable due to %s\n", reason);
 387                 /* Change only the rating, when not registered */
 388                 if (clocksource_tsc.mult)
 389                         clocksource_change_rating(&clocksource_tsc, 0);
 390                 else
 391                         clocksource_tsc.rating = 0;
 392         }
 393 }
 394
 395 EXPORT_SYMBOL_GPL(mark_tsc_unstable);
 396
 397 static int __init dmi_mark_tsc_unstable(const struct dmi_system_id *d)
 398 {
 399         printk(KERN_NOTICE "%s detected: marking TSC unstable.\n",
 400                         d->ident);
 401         tsc_unstable = 1;
 402         return 0;
 403 }
 404
 405 /* List of systems that have known TSC problems */
 406 static struct dmi_system_id __initdata bad_tsc_dmi_table[] = {
 407         {
 408                 .callback = dmi_mark_tsc_unstable,
 409                 .ident = "IBM Thinkpad 380XD",
 410                 .matches = {
 411                         DMI_MATCH(DMI_BOARD_VENDOR, "IBM"),
 412                         DMI_MATCH(DMI_BOARD_NAME, "2635FA0"),
 413                 },
 414         },
 415         {}
 416 };
 417
 418 /*
 419  * Geode_LX - the OLPC CPU has a possibly a very reliable TSC
 420  */
 421 #ifdef CONFIG_MGEODE_LX
 422 /* RTSC counts during suspend */
 423 #define RTSC_SUSP 0x100
 424
 425 static void __init check_geode_tsc_reliable(void)
 426 {
 427         unsigned long res_low, res_high;
 428
 429         rdmsr_safe(MSR_GEODE_BUSCONT_CONF0, &res_low, &res_high);
 430         if (res_low & RTSC_SUSP)
 431                 clocksource_tsc.flags &= ~CLOCK_SOURCE_MUST_VERIFY;
 432 }
 433 #else
 434 static inline void check_geode_tsc_reliable(void) { }
 435 #endif
 436
 437 /*
 438  * Make an educated guess if the TSC is trustworthy and synchronized
 439  * over all CPUs.
 440  */
 441 __cpuinit int unsynchronized_tsc(void)
 442 {
 443         if (!cpu_has_tsc || tsc_unstable)
 444                 return 1;
 445
 446 #ifdef CONFIG_SMP
 447         if (apic_is_clustered_box())
 448                 return 1;
 449 #endif
 450
 451         if (boot_cpu_has(X86_FEATURE_CONSTANT_TSC))
 452                 return 0;
 453         /*
 454          * Intel systems are normally all synchronized.
 455          * Exceptions must mark TSC as unstable:
 456          */
 457         if (boot_cpu_data.x86_vendor != X86_VENDOR_INTEL) {
 458                 /* assume multi socket systems are not synchronized: */
 459                 if (num_possible_cpus() > 1)
 460                         tsc_unstable = 1;
 461         }
 462
 463         return tsc_unstable;
 464 }
 465
 466 static void __init init_tsc_clocksource(void)
 467 {
 468         clocksource_tsc.mult = clocksource_khz2mult(tsc_khz,
 469                         clocksource_tsc.shift);
 470         /* lower the rating if we already know its unstable: */
 471         if (check_tsc_unstable()) {
 472                 clocksource_tsc.rating = 0;
 473                 clocksource_tsc.flags &= ~CLOCK_SOURCE_IS_CONTINUOUS;
 474         }
 475         clocksource_register(&clocksource_tsc);
 476 }
 477
 478 void __init tsc_init(void)
 479 {
 480         u64 lpj;
 481         int cpu;
 482
 483         if (!cpu_has_tsc)
 484                 return;
 485
 486         tsc_khz = calibrate_tsc();
 487         cpu_khz = tsc_khz;
 488
 489         if (!tsc_khz) {
 490                 mark_tsc_unstable("could not calculate TSC khz");
 491                 return;
 492         }
 493
 494 #ifdef CONFIG_X86_64
 495         if (cpu_has(&boot_cpu_data, X86_FEATURE_CONSTANT_TSC) &&
 496                         (boot_cpu_data.x86_vendor == X86_VENDOR_AMD))
 497                 cpu_khz = calibrate_cpu();
 498 #endif
 499
 500         lpj = ((u64)tsc_khz * 1000);
 501         do_div(lpj, HZ);
 502         lpj_fine = lpj;
 503
 504         printk("Detected %lu.%03lu MHz processor.\n",
 505                         (unsigned long)cpu_khz / 1000,
 506                         (unsigned long)cpu_khz % 1000);
 507
 508         /*
 509          * Secondary CPUs do not run through tsc_init(), so set up
 510          * all the scale factors for all CPUs, assuming the same
 511          * speed as the bootup CPU. (cpufreq notifiers will fix this
 512          * up if their speed diverges)
 513          */
 514         for_each_possible_cpu(cpu)
 515                 set_cyc2ns_scale(cpu_khz, cpu);
 516
 517         if (tsc_disabled > 0)
 518                 return;
 519
 520         /* now allow native_sched_clock() to use rdtsc */
 521         tsc_disabled = 0;
 522
 523         use_tsc_delay();
 524         /* Check and install the TSC clocksource */
 525         dmi_check_system(bad_tsc_dmi_table);
 526
 527         if (unsynchronized_tsc())
 528                 mark_tsc_unstable("TSCs unsynchronized");
 529
 530         check_geode_tsc_reliable();
 531         init_tsc_clocksource();
 532 }
 533