1 /* 2 * linux/kernel/time/clocksource.c 3 * 4 * This file contains the functions which manage clocksource drivers. 5 * 6 * Copyright (C) 2004, 2005 IBM, John Stultz (johnstul@us.ibm.com) 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License as published by 10 * the Free Software Foundation; either version 2 of the License, or 11 * (at your option) any later version. 12 * 13 * This program is distributed in the hope that it will be useful, 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 * GNU General Public License for more details. 17 * 18 * You should have received a copy of the GNU General Public License 19 * along with this program; if not, write to the Free Software 20 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 21 * 22 * TODO WishList: 23 * o Allow clocksource drivers to be unregistered 24 */ 25 26 #include <linux/device.h> 27 #include <linux/clocksource.h> 28 #include <linux/init.h> 29 #include <linux/module.h> 30 #include <linux/sched.h> /* for spin_unlock_irq() using preempt_count() m68k */ 31 #include <linux/tick.h> 32 #include <linux/kthread.h> 33 34 void timecounter_init(struct timecounter *tc, 35 const struct cyclecounter *cc, 36 u64 start_tstamp) 37 { 38 tc->cc = cc; 39 tc->cycle_last = cc->read(cc); 40 tc->nsec = start_tstamp; 41 } 42 EXPORT_SYMBOL_GPL(timecounter_init); 43 44 /** 45 * timecounter_read_delta - get nanoseconds since last call of this function 46 * @tc: Pointer to time counter 47 * 48 * When the underlying cycle counter runs over, this will be handled 49 * correctly as long as it does not run over more than once between 50 * calls. 51 * 52 * The first call to this function for a new time counter initializes 53 * the time tracking and returns an undefined result. 54 */ 55 static u64 timecounter_read_delta(struct timecounter *tc) 56 { 57 cycle_t cycle_now, cycle_delta; 58 u64 ns_offset; 59 60 /* read cycle counter: */ 61 cycle_now = tc->cc->read(tc->cc); 62 63 /* calculate the delta since the last timecounter_read_delta(): */ 64 cycle_delta = (cycle_now - tc->cycle_last) & tc->cc->mask; 65 66 /* convert to nanoseconds: */ 67 ns_offset = cyclecounter_cyc2ns(tc->cc, cycle_delta); 68 69 /* update time stamp of timecounter_read_delta() call: */ 70 tc->cycle_last = cycle_now; 71 72 return ns_offset; 73 } 74 75 u64 timecounter_read(struct timecounter *tc) 76 { 77 u64 nsec; 78 79 /* increment time by nanoseconds since last call */ 80 nsec = timecounter_read_delta(tc); 81 nsec += tc->nsec; 82 tc->nsec = nsec; 83 84 return nsec; 85 } 86 EXPORT_SYMBOL_GPL(timecounter_read); 87 88 u64 timecounter_cyc2time(struct timecounter *tc, 89 cycle_t cycle_tstamp) 90 { 91 u64 cycle_delta = (cycle_tstamp - tc->cycle_last) & tc->cc->mask; 92 u64 nsec; 93 94 /* 95 * Instead of always treating cycle_tstamp as more recent 96 * than tc->cycle_last, detect when it is too far in the 97 * future and treat it as old time stamp instead. 98 */ 99 if (cycle_delta > tc->cc->mask / 2) { 100 cycle_delta = (tc->cycle_last - cycle_tstamp) & tc->cc->mask; 101 nsec = tc->nsec - cyclecounter_cyc2ns(tc->cc, cycle_delta); 102 } else { 103 nsec = cyclecounter_cyc2ns(tc->cc, cycle_delta) + tc->nsec; 104 } 105 106 return nsec; 107 } 108 EXPORT_SYMBOL_GPL(timecounter_cyc2time); 109 110 /** 111 * clocks_calc_mult_shift - calculate mult/shift factors for scaled math of clocks 112 * @mult: pointer to mult variable 113 * @shift: pointer to shift variable 114 * @from: frequency to convert from 115 * @to: frequency to convert to 116 * @maxsec: guaranteed runtime conversion range in seconds 117 * 118 * The function evaluates the shift/mult pair for the scaled math 119 * operations of clocksources and clockevents. 120 * 121 * @to and @from are frequency values in HZ. For clock sources @to is 122 * NSEC_PER_SEC == 1GHz and @from is the counter frequency. For clock 123 * event @to is the counter frequency and @from is NSEC_PER_SEC. 124 * 125 * The @maxsec conversion range argument controls the time frame in 126 * seconds which must be covered by the runtime conversion with the 127 * calculated mult and shift factors. This guarantees that no 64bit 128 * overflow happens when the input value of the conversion is 129 * multiplied with the calculated mult factor. Larger ranges may 130 * reduce the conversion accuracy by chosing smaller mult and shift 131 * factors. 132 */ 133 void 134 clocks_calc_mult_shift(u32 *mult, u32 *shift, u32 from, u32 to, u32 maxsec) 135 { 136 u64 tmp; 137 u32 sft, sftacc= 32; 138 139 /* 140 * Calculate the shift factor which is limiting the conversion 141 * range: 142 */ 143 tmp = ((u64)maxsec * from) >> 32; 144 while (tmp) { 145 tmp >>=1; 146 sftacc--; 147 } 148 149 /* 150 * Find the conversion shift/mult pair which has the best 151 * accuracy and fits the maxsec conversion range: 152 */ 153 for (sft = 32; sft > 0; sft--) { 154 tmp = (u64) to << sft; 155 tmp += from / 2; 156 do_div(tmp, from); 157 if ((tmp >> sftacc) == 0) 158 break; 159 } 160 *mult = tmp; 161 *shift = sft; 162 } 163 164 /*[Clocksource internal variables]--------- 165 * curr_clocksource: 166 * currently selected clocksource. 167 * clocksource_list: 168 * linked list with the registered clocksources 169 * clocksource_mutex: 170 * protects manipulations to curr_clocksource and the clocksource_list 171 * override_name: 172 * Name of the user-specified clocksource. 173 */ 174 static struct clocksource *curr_clocksource; 175 static LIST_HEAD(clocksource_list); 176 static DEFINE_MUTEX(clocksource_mutex); 177 static char override_name[32]; 178 static int finished_booting; 179 180 #ifdef CONFIG_CLOCKSOURCE_WATCHDOG 181 static void clocksource_watchdog_work(struct work_struct *work); 182 183 static LIST_HEAD(watchdog_list); 184 static struct clocksource *watchdog; 185 static struct timer_list watchdog_timer; 186 static DECLARE_WORK(watchdog_work, clocksource_watchdog_work); 187 static DEFINE_SPINLOCK(watchdog_lock); 188 static int watchdog_running; 189 static atomic_t watchdog_reset_pending; 190 191 static int clocksource_watchdog_kthread(void *data); 192 static void __clocksource_change_rating(struct clocksource *cs, int rating); 193 194 /* 195 * Interval: 0.5sec Threshold: 0.0625s 196 */ 197 #define WATCHDOG_INTERVAL (HZ >> 1) 198 #define WATCHDOG_THRESHOLD (NSEC_PER_SEC >> 4) 199 200 static void clocksource_watchdog_work(struct work_struct *work) 201 { 202 /* 203 * If kthread_run fails the next watchdog scan over the 204 * watchdog_list will find the unstable clock again. 205 */ 206 kthread_run(clocksource_watchdog_kthread, NULL, "kwatchdog"); 207 } 208 209 static void __clocksource_unstable(struct clocksource *cs) 210 { 211 cs->flags &= ~(CLOCK_SOURCE_VALID_FOR_HRES | CLOCK_SOURCE_WATCHDOG); 212 cs->flags |= CLOCK_SOURCE_UNSTABLE; 213 if (finished_booting) 214 schedule_work(&watchdog_work); 215 } 216 217 static void clocksource_unstable(struct clocksource *cs, int64_t delta) 218 { 219 printk(KERN_WARNING "Clocksource %s unstable (delta = %Ld ns)\n", 220 cs->name, delta); 221 __clocksource_unstable(cs); 222 } 223 224 /** 225 * clocksource_mark_unstable - mark clocksource unstable via watchdog 226 * @cs: clocksource to be marked unstable 227 * 228 * This function is called instead of clocksource_change_rating from 229 * cpu hotplug code to avoid a deadlock between the clocksource mutex 230 * and the cpu hotplug mutex. It defers the update of the clocksource 231 * to the watchdog thread. 232 */ 233 void clocksource_mark_unstable(struct clocksource *cs) 234 { 235 unsigned long flags; 236 237 spin_lock_irqsave(&watchdog_lock, flags); 238 if (!(cs->flags & CLOCK_SOURCE_UNSTABLE)) { 239 if (list_empty(&cs->wd_list)) 240 list_add(&cs->wd_list, &watchdog_list); 241 __clocksource_unstable(cs); 242 } 243 spin_unlock_irqrestore(&watchdog_lock, flags); 244 } 245 246 static void clocksource_watchdog(unsigned long data) 247 { 248 struct clocksource *cs; 249 cycle_t csnow, wdnow; 250 int64_t wd_nsec, cs_nsec; 251 int next_cpu, reset_pending; 252 253 spin_lock(&watchdog_lock); 254 if (!watchdog_running) 255 goto out; 256 257 reset_pending = atomic_read(&watchdog_reset_pending); 258 259 list_for_each_entry(cs, &watchdog_list, wd_list) { 260 261 /* Clocksource already marked unstable? */ 262 if (cs->flags & CLOCK_SOURCE_UNSTABLE) { 263 if (finished_booting) 264 schedule_work(&watchdog_work); 265 continue; 266 } 267 268 local_irq_disable(); 269 csnow = cs->read(cs); 270 wdnow = watchdog->read(watchdog); 271 local_irq_enable(); 272 273 /* Clocksource initialized ? */ 274 if (!(cs->flags & CLOCK_SOURCE_WATCHDOG) || 275 atomic_read(&watchdog_reset_pending)) { 276 cs->flags |= CLOCK_SOURCE_WATCHDOG; 277 cs->wd_last = wdnow; 278 cs->cs_last = csnow; 279 continue; 280 } 281 282 wd_nsec = clocksource_cyc2ns((wdnow - cs->wd_last) & watchdog->mask, 283 watchdog->mult, watchdog->shift); 284 285 cs_nsec = clocksource_cyc2ns((csnow - cs->cs_last) & 286 cs->mask, cs->mult, cs->shift); 287 cs->cs_last = csnow; 288 cs->wd_last = wdnow; 289 290 if (atomic_read(&watchdog_reset_pending)) 291 continue; 292 293 /* Check the deviation from the watchdog clocksource. */ 294 if ((abs(cs_nsec - wd_nsec) > WATCHDOG_THRESHOLD)) { 295 clocksource_unstable(cs, cs_nsec - wd_nsec); 296 continue; 297 } 298 299 if (!(cs->flags & CLOCK_SOURCE_VALID_FOR_HRES) && 300 (cs->flags & CLOCK_SOURCE_IS_CONTINUOUS) && 301 (watchdog->flags & CLOCK_SOURCE_IS_CONTINUOUS)) { 302 cs->flags |= CLOCK_SOURCE_VALID_FOR_HRES; 303 /* 304 * We just marked the clocksource as highres-capable, 305 * notify the rest of the system as well so that we 306 * transition into high-res mode: 307 */ 308 tick_clock_notify(); 309 } 310 } 311 312 /* 313 * We only clear the watchdog_reset_pending, when we did a 314 * full cycle through all clocksources. 315 */ 316 if (reset_pending) 317 atomic_dec(&watchdog_reset_pending); 318 319 /* 320 * Cycle through CPUs to check if the CPUs stay synchronized 321 * to each other. 322 */ 323 next_cpu = cpumask_next(raw_smp_processor_id(), cpu_online_mask); 324 if (next_cpu >= nr_cpu_ids) 325 next_cpu = cpumask_first(cpu_online_mask); 326 watchdog_timer.expires += WATCHDOG_INTERVAL; 327 add_timer_on(&watchdog_timer, next_cpu); 328 out: 329 spin_unlock(&watchdog_lock); 330 } 331 332 static inline void clocksource_start_watchdog(void) 333 { 334 if (watchdog_running || !watchdog || list_empty(&watchdog_list)) 335 return; 336 init_timer(&watchdog_timer); 337 watchdog_timer.function = clocksource_watchdog; 338 watchdog_timer.expires = jiffies + WATCHDOG_INTERVAL; 339 add_timer_on(&watchdog_timer, cpumask_first(cpu_online_mask)); 340 watchdog_running = 1; 341 } 342 343 static inline void clocksource_stop_watchdog(void) 344 { 345 if (!watchdog_running || (watchdog && !list_empty(&watchdog_list))) 346 return; 347 del_timer(&watchdog_timer); 348 watchdog_running = 0; 349 } 350 351 static inline void clocksource_reset_watchdog(void) 352 { 353 struct clocksource *cs; 354 355 list_for_each_entry(cs, &watchdog_list, wd_list) 356 cs->flags &= ~CLOCK_SOURCE_WATCHDOG; 357 } 358 359 static void clocksource_resume_watchdog(void) 360 { 361 atomic_inc(&watchdog_reset_pending); 362 } 363 364 static void clocksource_enqueue_watchdog(struct clocksource *cs) 365 { 366 unsigned long flags; 367 368 spin_lock_irqsave(&watchdog_lock, flags); 369 if (cs->flags & CLOCK_SOURCE_MUST_VERIFY) { 370 /* cs is a clocksource to be watched. */ 371 list_add(&cs->wd_list, &watchdog_list); 372 cs->flags &= ~CLOCK_SOURCE_WATCHDOG; 373 } else { 374 /* cs is a watchdog. */ 375 if (cs->flags & CLOCK_SOURCE_IS_CONTINUOUS) 376 cs->flags |= CLOCK_SOURCE_VALID_FOR_HRES; 377 /* Pick the best watchdog. */ 378 if (!watchdog || cs->rating > watchdog->rating) { 379 watchdog = cs; 380 /* Reset watchdog cycles */ 381 clocksource_reset_watchdog(); 382 } 383 } 384 /* Check if the watchdog timer needs to be started. */ 385 clocksource_start_watchdog(); 386 spin_unlock_irqrestore(&watchdog_lock, flags); 387 } 388 389 static void clocksource_dequeue_watchdog(struct clocksource *cs) 390 { 391 struct clocksource *tmp; 392 unsigned long flags; 393 394 spin_lock_irqsave(&watchdog_lock, flags); 395 if (cs->flags & CLOCK_SOURCE_MUST_VERIFY) { 396 /* cs is a watched clocksource. */ 397 list_del_init(&cs->wd_list); 398 } else if (cs == watchdog) { 399 /* Reset watchdog cycles */ 400 clocksource_reset_watchdog(); 401 /* Current watchdog is removed. Find an alternative. */ 402 watchdog = NULL; 403 list_for_each_entry(tmp, &clocksource_list, list) { 404 if (tmp == cs || tmp->flags & CLOCK_SOURCE_MUST_VERIFY) 405 continue; 406 if (!watchdog || tmp->rating > watchdog->rating) 407 watchdog = tmp; 408 } 409 } 410 cs->flags &= ~CLOCK_SOURCE_WATCHDOG; 411 /* Check if the watchdog timer needs to be stopped. */ 412 clocksource_stop_watchdog(); 413 spin_unlock_irqrestore(&watchdog_lock, flags); 414 } 415 416 static int clocksource_watchdog_kthread(void *data) 417 { 418 struct clocksource *cs, *tmp; 419 unsigned long flags; 420 LIST_HEAD(unstable); 421 422 mutex_lock(&clocksource_mutex); 423 spin_lock_irqsave(&watchdog_lock, flags); 424 list_for_each_entry_safe(cs, tmp, &watchdog_list, wd_list) 425 if (cs->flags & CLOCK_SOURCE_UNSTABLE) { 426 list_del_init(&cs->wd_list); 427 list_add(&cs->wd_list, &unstable); 428 } 429 /* Check if the watchdog timer needs to be stopped. */ 430 clocksource_stop_watchdog(); 431 spin_unlock_irqrestore(&watchdog_lock, flags); 432 433 /* Needs to be done outside of watchdog lock */ 434 list_for_each_entry_safe(cs, tmp, &unstable, wd_list) { 435 list_del_init(&cs->wd_list); 436 __clocksource_change_rating(cs, 0); 437 } 438 mutex_unlock(&clocksource_mutex); 439 return 0; 440 } 441 442 #else /* CONFIG_CLOCKSOURCE_WATCHDOG */ 443 444 static void clocksource_enqueue_watchdog(struct clocksource *cs) 445 { 446 if (cs->flags & CLOCK_SOURCE_IS_CONTINUOUS) 447 cs->flags |= CLOCK_SOURCE_VALID_FOR_HRES; 448 } 449 450 static inline void clocksource_dequeue_watchdog(struct clocksource *cs) { } 451 static inline void clocksource_resume_watchdog(void) { } 452 static inline int clocksource_watchdog_kthread(void *data) { return 0; } 453 454 #endif /* CONFIG_CLOCKSOURCE_WATCHDOG */ 455 456 /** 457 * clocksource_suspend - suspend the clocksource(s) 458 */ 459 void clocksource_suspend(void) 460 { 461 struct clocksource *cs; 462 463 list_for_each_entry_reverse(cs, &clocksource_list, list) 464 if (cs->suspend) 465 cs->suspend(cs); 466 } 467 468 /** 469 * clocksource_resume - resume the clocksource(s) 470 */ 471 void clocksource_resume(void) 472 { 473 struct clocksource *cs; 474 475 list_for_each_entry(cs, &clocksource_list, list) 476 if (cs->resume) 477 cs->resume(cs); 478 479 clocksource_resume_watchdog(); 480 } 481 482 /** 483 * clocksource_touch_watchdog - Update watchdog 484 * 485 * Update the watchdog after exception contexts such as kgdb so as not 486 * to incorrectly trip the watchdog. This might fail when the kernel 487 * was stopped in code which holds watchdog_lock. 488 */ 489 void clocksource_touch_watchdog(void) 490 { 491 clocksource_resume_watchdog(); 492 } 493 494 /** 495 * clocksource_max_adjustment- Returns max adjustment amount 496 * @cs: Pointer to clocksource 497 * 498 */ 499 static u32 clocksource_max_adjustment(struct clocksource *cs) 500 { 501 u64 ret; 502 /* 503 * We won't try to correct for more than 11% adjustments (110,000 ppm), 504 */ 505 ret = (u64)cs->mult * 11; 506 do_div(ret,100); 507 return (u32)ret; 508 } 509 510 /** 511 * clocksource_max_deferment - Returns max time the clocksource can be deferred 512 * @cs: Pointer to clocksource 513 * 514 */ 515 static u64 clocksource_max_deferment(struct clocksource *cs) 516 { 517 u64 max_nsecs, max_cycles; 518 519 /* 520 * Calculate the maximum number of cycles that we can pass to the 521 * cyc2ns function without overflowing a 64-bit signed result. The 522 * maximum number of cycles is equal to ULLONG_MAX/(cs->mult+cs->maxadj) 523 * which is equivalent to the below. 524 * max_cycles < (2^63)/(cs->mult + cs->maxadj) 525 * max_cycles < 2^(log2((2^63)/(cs->mult + cs->maxadj))) 526 * max_cycles < 2^(log2(2^63) - log2(cs->mult + cs->maxadj)) 527 * max_cycles < 2^(63 - log2(cs->mult + cs->maxadj)) 528 * max_cycles < 1 << (63 - log2(cs->mult + cs->maxadj)) 529 * Please note that we add 1 to the result of the log2 to account for 530 * any rounding errors, ensure the above inequality is satisfied and 531 * no overflow will occur. 532 */ 533 max_cycles = 1ULL << (63 - (ilog2(cs->mult + cs->maxadj) + 1)); 534 535 /* 536 * The actual maximum number of cycles we can defer the clocksource is 537 * determined by the minimum of max_cycles and cs->mask. 538 * Note: Here we subtract the maxadj to make sure we don't sleep for 539 * too long if there's a large negative adjustment. 540 */ 541 max_cycles = min_t(u64, max_cycles, (u64) cs->mask); 542 max_nsecs = clocksource_cyc2ns(max_cycles, cs->mult - cs->maxadj, 543 cs->shift); 544 545 /* 546 * To ensure that the clocksource does not wrap whilst we are idle, 547 * limit the time the clocksource can be deferred by 12.5%. Please 548 * note a margin of 12.5% is used because this can be computed with 549 * a shift, versus say 10% which would require division. 550 */ 551 return max_nsecs - (max_nsecs >> 3); 552 } 553 554 #ifndef CONFIG_ARCH_USES_GETTIMEOFFSET 555 556 /** 557 * clocksource_select - Select the best clocksource available 558 * 559 * Private function. Must hold clocksource_mutex when called. 560 * 561 * Select the clocksource with the best rating, or the clocksource, 562 * which is selected by userspace override. 563 */ 564 static void clocksource_select(void) 565 { 566 struct clocksource *best, *cs; 567 568 if (!finished_booting || list_empty(&clocksource_list)) 569 return; 570 /* First clocksource on the list has the best rating. */ 571 best = list_first_entry(&clocksource_list, struct clocksource, list); 572 /* Check for the override clocksource. */ 573 list_for_each_entry(cs, &clocksource_list, list) { 574 if (strcmp(cs->name, override_name) != 0) 575 continue; 576 /* 577 * Check to make sure we don't switch to a non-highres 578 * capable clocksource if the tick code is in oneshot 579 * mode (highres or nohz) 580 */ 581 if (!(cs->flags & CLOCK_SOURCE_VALID_FOR_HRES) && 582 tick_oneshot_mode_active()) { 583 /* Override clocksource cannot be used. */ 584 printk(KERN_WARNING "Override clocksource %s is not " 585 "HRT compatible. Cannot switch while in " 586 "HRT/NOHZ mode\n", cs->name); 587 override_name[0] = 0; 588 } else 589 /* Override clocksource can be used. */ 590 best = cs; 591 break; 592 } 593 if (curr_clocksource != best) { 594 printk(KERN_INFO "Switching to clocksource %s\n", best->name); 595 curr_clocksource = best; 596 timekeeping_notify(curr_clocksource); 597 } 598 } 599 600 #else /* !CONFIG_ARCH_USES_GETTIMEOFFSET */ 601 602 static inline void clocksource_select(void) { } 603 604 #endif 605 606 /* 607 * clocksource_done_booting - Called near the end of core bootup 608 * 609 * Hack to avoid lots of clocksource churn at boot time. 610 * We use fs_initcall because we want this to start before 611 * device_initcall but after subsys_initcall. 612 */ 613 static int __init clocksource_done_booting(void) 614 { 615 mutex_lock(&clocksource_mutex); 616 curr_clocksource = clocksource_default_clock(); 617 mutex_unlock(&clocksource_mutex); 618 619 finished_booting = 1; 620 621 /* 622 * Run the watchdog first to eliminate unstable clock sources 623 */ 624 clocksource_watchdog_kthread(NULL); 625 626 mutex_lock(&clocksource_mutex); 627 clocksource_select(); 628 mutex_unlock(&clocksource_mutex); 629 return 0; 630 } 631 fs_initcall(clocksource_done_booting); 632 633 /* 634 * Enqueue the clocksource sorted by rating 635 */ 636 static void clocksource_enqueue(struct clocksource *cs) 637 { 638 struct list_head *entry = &clocksource_list; 639 struct clocksource *tmp; 640 641 list_for_each_entry(tmp, &clocksource_list, list) 642 /* Keep track of the place, where to insert */ 643 if (tmp->rating >= cs->rating) 644 entry = &tmp->list; 645 list_add(&cs->list, entry); 646 } 647 648 /** 649 * __clocksource_updatefreq_scale - Used update clocksource with new freq 650 * @cs: clocksource to be registered 651 * @scale: Scale factor multiplied against freq to get clocksource hz 652 * @freq: clocksource frequency (cycles per second) divided by scale 653 * 654 * This should only be called from the clocksource->enable() method. 655 * 656 * This *SHOULD NOT* be called directly! Please use the 657 * clocksource_updatefreq_hz() or clocksource_updatefreq_khz helper functions. 658 */ 659 void __clocksource_updatefreq_scale(struct clocksource *cs, u32 scale, u32 freq) 660 { 661 u64 sec; 662 /* 663 * Calc the maximum number of seconds which we can run before 664 * wrapping around. For clocksources which have a mask > 32bit 665 * we need to limit the max sleep time to have a good 666 * conversion precision. 10 minutes is still a reasonable 667 * amount. That results in a shift value of 24 for a 668 * clocksource with mask >= 40bit and f >= 4GHz. That maps to 669 * ~ 0.06ppm granularity for NTP. We apply the same 12.5% 670 * margin as we do in clocksource_max_deferment() 671 */ 672 sec = (cs->mask - (cs->mask >> 3)); 673 do_div(sec, freq); 674 do_div(sec, scale); 675 if (!sec) 676 sec = 1; 677 else if (sec > 600 && cs->mask > UINT_MAX) 678 sec = 600; 679 680 clocks_calc_mult_shift(&cs->mult, &cs->shift, freq, 681 NSEC_PER_SEC / scale, sec * scale); 682 683 /* 684 * for clocksources that have large mults, to avoid overflow. 685 * Since mult may be adjusted by ntp, add an safety extra margin 686 * 687 */ 688 cs->maxadj = clocksource_max_adjustment(cs); 689 while ((cs->mult + cs->maxadj < cs->mult) 690 || (cs->mult - cs->maxadj > cs->mult)) { 691 cs->mult >>= 1; 692 cs->shift--; 693 cs->maxadj = clocksource_max_adjustment(cs); 694 } 695 696 cs->max_idle_ns = clocksource_max_deferment(cs); 697 } 698 EXPORT_SYMBOL_GPL(__clocksource_updatefreq_scale); 699 700 /** 701 * __clocksource_register_scale - Used to install new clocksources 702 * @cs: clocksource to be registered 703 * @scale: Scale factor multiplied against freq to get clocksource hz 704 * @freq: clocksource frequency (cycles per second) divided by scale 705 * 706 * Returns -EBUSY if registration fails, zero otherwise. 707 * 708 * This *SHOULD NOT* be called directly! Please use the 709 * clocksource_register_hz() or clocksource_register_khz helper functions. 710 */ 711 int __clocksource_register_scale(struct clocksource *cs, u32 scale, u32 freq) 712 { 713 714 /* Initialize mult/shift and max_idle_ns */ 715 __clocksource_updatefreq_scale(cs, scale, freq); 716 717 /* Add clocksource to the clcoksource list */ 718 mutex_lock(&clocksource_mutex); 719 clocksource_enqueue(cs); 720 clocksource_enqueue_watchdog(cs); 721 clocksource_select(); 722 mutex_unlock(&clocksource_mutex); 723 return 0; 724 } 725 EXPORT_SYMBOL_GPL(__clocksource_register_scale); 726 727 728 /** 729 * clocksource_register - Used to install new clocksources 730 * @cs: clocksource to be registered 731 * 732 * Returns -EBUSY if registration fails, zero otherwise. 733 */ 734 int clocksource_register(struct clocksource *cs) 735 { 736 /* calculate max adjustment for given mult/shift */ 737 cs->maxadj = clocksource_max_adjustment(cs); 738 WARN_ONCE(cs->mult + cs->maxadj < cs->mult, 739 "Clocksource %s might overflow on 11%% adjustment\n", 740 cs->name); 741 742 /* calculate max idle time permitted for this clocksource */ 743 cs->max_idle_ns = clocksource_max_deferment(cs); 744 745 mutex_lock(&clocksource_mutex); 746 clocksource_enqueue(cs); 747 clocksource_enqueue_watchdog(cs); 748 clocksource_select(); 749 mutex_unlock(&clocksource_mutex); 750 return 0; 751 } 752 EXPORT_SYMBOL(clocksource_register); 753 754 static void __clocksource_change_rating(struct clocksource *cs, int rating) 755 { 756 list_del(&cs->list); 757 cs->rating = rating; 758 clocksource_enqueue(cs); 759 clocksource_select(); 760 } 761 762 /** 763 * clocksource_change_rating - Change the rating of a registered clocksource 764 * @cs: clocksource to be changed 765 * @rating: new rating 766 */ 767 void clocksource_change_rating(struct clocksource *cs, int rating) 768 { 769 mutex_lock(&clocksource_mutex); 770 __clocksource_change_rating(cs, rating); 771 mutex_unlock(&clocksource_mutex); 772 } 773 EXPORT_SYMBOL(clocksource_change_rating); 774 775 /** 776 * clocksource_unregister - remove a registered clocksource 777 * @cs: clocksource to be unregistered 778 */ 779 void clocksource_unregister(struct clocksource *cs) 780 { 781 mutex_lock(&clocksource_mutex); 782 clocksource_dequeue_watchdog(cs); 783 list_del(&cs->list); 784 clocksource_select(); 785 mutex_unlock(&clocksource_mutex); 786 } 787 EXPORT_SYMBOL(clocksource_unregister); 788 789 #ifdef CONFIG_SYSFS 790 /** 791 * sysfs_show_current_clocksources - sysfs interface for current clocksource 792 * @dev: unused 793 * @attr: unused 794 * @buf: char buffer to be filled with clocksource list 795 * 796 * Provides sysfs interface for listing current clocksource. 797 */ 798 static ssize_t 799 sysfs_show_current_clocksources(struct device *dev, 800 struct device_attribute *attr, char *buf) 801 { 802 ssize_t count = 0; 803 804 mutex_lock(&clocksource_mutex); 805 count = snprintf(buf, PAGE_SIZE, "%s\n", curr_clocksource->name); 806 mutex_unlock(&clocksource_mutex); 807 808 return count; 809 } 810 811 /** 812 * sysfs_override_clocksource - interface for manually overriding clocksource 813 * @dev: unused 814 * @attr: unused 815 * @buf: name of override clocksource 816 * @count: length of buffer 817 * 818 * Takes input from sysfs interface for manually overriding the default 819 * clocksource selection. 820 */ 821 static ssize_t sysfs_override_clocksource(struct device *dev, 822 struct device_attribute *attr, 823 const char *buf, size_t count) 824 { 825 size_t ret = count; 826 827 /* strings from sysfs write are not 0 terminated! */ 828 if (count >= sizeof(override_name)) 829 return -EINVAL; 830 831 /* strip of \n: */ 832 if (buf[count-1] == '\n') 833 count--; 834 835 mutex_lock(&clocksource_mutex); 836 837 if (count > 0) 838 memcpy(override_name, buf, count); 839 override_name[count] = 0; 840 clocksource_select(); 841 842 mutex_unlock(&clocksource_mutex); 843 844 return ret; 845 } 846 847 /** 848 * sysfs_show_available_clocksources - sysfs interface for listing clocksource 849 * @dev: unused 850 * @attr: unused 851 * @buf: char buffer to be filled with clocksource list 852 * 853 * Provides sysfs interface for listing registered clocksources 854 */ 855 static ssize_t 856 sysfs_show_available_clocksources(struct device *dev, 857 struct device_attribute *attr, 858 char *buf) 859 { 860 struct clocksource *src; 861 ssize_t count = 0; 862 863 mutex_lock(&clocksource_mutex); 864 list_for_each_entry(src, &clocksource_list, list) { 865 /* 866 * Don't show non-HRES clocksource if the tick code is 867 * in one shot mode (highres=on or nohz=on) 868 */ 869 if (!tick_oneshot_mode_active() || 870 (src->flags & CLOCK_SOURCE_VALID_FOR_HRES)) 871 count += snprintf(buf + count, 872 max((ssize_t)PAGE_SIZE - count, (ssize_t)0), 873 "%s ", src->name); 874 } 875 mutex_unlock(&clocksource_mutex); 876 877 count += snprintf(buf + count, 878 max((ssize_t)PAGE_SIZE - count, (ssize_t)0), "\n"); 879 880 return count; 881 } 882 883 /* 884 * Sysfs setup bits: 885 */ 886 static DEVICE_ATTR(current_clocksource, 0644, sysfs_show_current_clocksources, 887 sysfs_override_clocksource); 888 889 static DEVICE_ATTR(available_clocksource, 0444, 890 sysfs_show_available_clocksources, NULL); 891 892 static struct bus_type clocksource_subsys = { 893 .name = "clocksource", 894 .dev_name = "clocksource", 895 }; 896 897 static struct device device_clocksource = { 898 .id = 0, 899 .bus = &clocksource_subsys, 900 }; 901 902 static int __init init_clocksource_sysfs(void) 903 { 904 int error = subsys_system_register(&clocksource_subsys, NULL); 905 906 if (!error) 907 error = device_register(&device_clocksource); 908 if (!error) 909 error = device_create_file( 910 &device_clocksource, 911 &dev_attr_current_clocksource); 912 if (!error) 913 error = device_create_file( 914 &device_clocksource, 915 &dev_attr_available_clocksource); 916 return error; 917 } 918 919 device_initcall(init_clocksource_sysfs); 920 #endif /* CONFIG_SYSFS */ 921 922 /** 923 * boot_override_clocksource - boot clock override 924 * @str: override name 925 * 926 * Takes a clocksource= boot argument and uses it 927 * as the clocksource override name. 928 */ 929 static int __init boot_override_clocksource(char* str) 930 { 931 mutex_lock(&clocksource_mutex); 932 if (str) 933 strlcpy(override_name, str, sizeof(override_name)); 934 mutex_unlock(&clocksource_mutex); 935 return 1; 936 } 937 938 __setup("clocksource=", boot_override_clocksource); 939 940 /** 941 * boot_override_clock - Compatibility layer for deprecated boot option 942 * @str: override name 943 * 944 * DEPRECATED! Takes a clock= boot argument and uses it 945 * as the clocksource override name 946 */ 947 static int __init boot_override_clock(char* str) 948 { 949 if (!strcmp(str, "pmtmr")) { 950 printk("Warning: clock=pmtmr is deprecated. " 951 "Use clocksource=acpi_pm.\n"); 952 return boot_override_clocksource("acpi_pm"); 953 } 954 printk("Warning! clock= boot option is deprecated. " 955 "Use clocksource=xyz\n"); 956 return boot_override_clocksource(str); 957 } 958 959 __setup("clock=", boot_override_clock); 960