Andrew Scull | b4b6d4a | 2019-01-02 15:54:55 +0000 | [diff] [blame] | 1 | /*********************************************************************** |
| 2 | * linux/kernel/time/jiffies.c |
| 3 | * |
| 4 | * This file contains the jiffies based clocksource. |
| 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 | ************************************************************************/ |
| 23 | #include <linux/clocksource.h> |
| 24 | #include <linux/jiffies.h> |
| 25 | #include <linux/module.h> |
| 26 | #include <linux/init.h> |
| 27 | |
| 28 | #include "timekeeping.h" |
| 29 | |
| 30 | |
| 31 | /* Since jiffies uses a simple TICK_NSEC multiplier |
| 32 | * conversion, the .shift value could be zero. However |
| 33 | * this would make NTP adjustments impossible as they are |
| 34 | * in units of 1/2^.shift. Thus we use JIFFIES_SHIFT to |
| 35 | * shift both the nominator and denominator the same |
| 36 | * amount, and give ntp adjustments in units of 1/2^8 |
| 37 | * |
| 38 | * The value 8 is somewhat carefully chosen, as anything |
| 39 | * larger can result in overflows. TICK_NSEC grows as HZ |
| 40 | * shrinks, so values greater than 8 overflow 32bits when |
| 41 | * HZ=100. |
| 42 | */ |
| 43 | #if HZ < 34 |
| 44 | #define JIFFIES_SHIFT 6 |
| 45 | #elif HZ < 67 |
| 46 | #define JIFFIES_SHIFT 7 |
| 47 | #else |
| 48 | #define JIFFIES_SHIFT 8 |
| 49 | #endif |
| 50 | |
| 51 | static u64 jiffies_read(struct clocksource *cs) |
| 52 | { |
| 53 | return (u64) jiffies; |
| 54 | } |
| 55 | |
| 56 | /* |
| 57 | * The Jiffies based clocksource is the lowest common |
| 58 | * denominator clock source which should function on |
| 59 | * all systems. It has the same coarse resolution as |
| 60 | * the timer interrupt frequency HZ and it suffers |
| 61 | * inaccuracies caused by missed or lost timer |
| 62 | * interrupts and the inability for the timer |
| 63 | * interrupt hardware to accuratly tick at the |
| 64 | * requested HZ value. It is also not recommended |
| 65 | * for "tick-less" systems. |
| 66 | */ |
| 67 | static struct clocksource clocksource_jiffies = { |
| 68 | .name = "jiffies", |
| 69 | .rating = 1, /* lowest valid rating*/ |
| 70 | .read = jiffies_read, |
| 71 | .mask = CLOCKSOURCE_MASK(32), |
| 72 | .mult = TICK_NSEC << JIFFIES_SHIFT, /* details above */ |
| 73 | .shift = JIFFIES_SHIFT, |
| 74 | .max_cycles = 10, |
| 75 | }; |
| 76 | |
| 77 | __cacheline_aligned_in_smp DEFINE_SEQLOCK(jiffies_lock); |
| 78 | |
| 79 | #if (BITS_PER_LONG < 64) |
| 80 | u64 get_jiffies_64(void) |
| 81 | { |
| 82 | unsigned long seq; |
| 83 | u64 ret; |
| 84 | |
| 85 | do { |
| 86 | seq = read_seqbegin(&jiffies_lock); |
| 87 | ret = jiffies_64; |
| 88 | } while (read_seqretry(&jiffies_lock, seq)); |
| 89 | return ret; |
| 90 | } |
| 91 | EXPORT_SYMBOL(get_jiffies_64); |
| 92 | #endif |
| 93 | |
| 94 | EXPORT_SYMBOL(jiffies); |
| 95 | |
| 96 | static int __init init_jiffies_clocksource(void) |
| 97 | { |
| 98 | return __clocksource_register(&clocksource_jiffies); |
| 99 | } |
| 100 | |
| 101 | core_initcall(init_jiffies_clocksource); |
| 102 | |
| 103 | struct clocksource * __init __weak clocksource_default_clock(void) |
| 104 | { |
| 105 | return &clocksource_jiffies; |
| 106 | } |
| 107 | |
| 108 | struct clocksource refined_jiffies; |
| 109 | |
| 110 | int register_refined_jiffies(long cycles_per_second) |
| 111 | { |
| 112 | u64 nsec_per_tick, shift_hz; |
| 113 | long cycles_per_tick; |
| 114 | |
| 115 | |
| 116 | |
| 117 | refined_jiffies = clocksource_jiffies; |
| 118 | refined_jiffies.name = "refined-jiffies"; |
| 119 | refined_jiffies.rating++; |
| 120 | |
| 121 | /* Calc cycles per tick */ |
| 122 | cycles_per_tick = (cycles_per_second + HZ/2)/HZ; |
| 123 | /* shift_hz stores hz<<8 for extra accuracy */ |
| 124 | shift_hz = (u64)cycles_per_second << 8; |
| 125 | shift_hz += cycles_per_tick/2; |
| 126 | do_div(shift_hz, cycles_per_tick); |
| 127 | /* Calculate nsec_per_tick using shift_hz */ |
| 128 | nsec_per_tick = (u64)NSEC_PER_SEC << 8; |
| 129 | nsec_per_tick += (u32)shift_hz/2; |
| 130 | do_div(nsec_per_tick, (u32)shift_hz); |
| 131 | |
| 132 | refined_jiffies.mult = ((u32)nsec_per_tick) << JIFFIES_SHIFT; |
| 133 | |
| 134 | __clocksource_register(&refined_jiffies); |
| 135 | return 0; |
| 136 | } |