1 /* 2 * Common time prototypes and such for 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 * 7 * This program is free software; you can redistribute it and/or 8 * modify it under the terms of the GNU General Public License 9 * as published by the Free Software Foundation; either version 10 * 2 of the License, or (at your option) any later version. 11 */ 12 13 #ifndef __POWERPC_TIME_H 14 #define __POWERPC_TIME_H 15 16 #ifdef __KERNEL__ 17 #include <linux/types.h> 18 #include <linux/percpu.h> 19 20 #include <asm/processor.h> 21 #ifdef CONFIG_PPC_ISERIES 22 #include <asm/paca.h> 23 #include <asm/firmware.h> 24 #include <asm/iseries/hv_call.h> 25 #endif 26 27 /* time.c */ 28 extern unsigned long tb_ticks_per_jiffy; 29 extern unsigned long tb_ticks_per_usec; 30 extern unsigned long tb_ticks_per_sec; 31 extern u64 tb_to_xs; 32 extern unsigned tb_to_us; 33 34 struct rtc_time; 35 extern void to_tm(int tim, struct rtc_time * tm); 36 extern void GregorianDay(struct rtc_time *tm); 37 extern time_t last_rtc_update; 38 39 extern void generic_calibrate_decr(void); 40 extern void wakeup_decrementer(void); 41 extern void snapshot_timebase(void); 42 43 extern void set_dec_cpu6(unsigned int val); 44 45 /* Some sane defaults: 125 MHz timebase, 1GHz processor */ 46 extern unsigned long ppc_proc_freq; 47 #define DEFAULT_PROC_FREQ (DEFAULT_TB_FREQ * 8) 48 extern unsigned long ppc_tb_freq; 49 #define DEFAULT_TB_FREQ 125000000UL 50 51 /* 52 * By putting all of this stuff into a single struct we 53 * reduce the number of cache lines touched by do_gettimeofday. 54 * Both by collecting all of the data in one cache line and 55 * by touching only one TOC entry on ppc64. 56 */ 57 struct gettimeofday_vars { 58 u64 tb_to_xs; 59 u64 stamp_xsec; 60 u64 tb_orig_stamp; 61 }; 62 63 struct gettimeofday_struct { 64 unsigned long tb_ticks_per_sec; 65 struct gettimeofday_vars vars[2]; 66 struct gettimeofday_vars * volatile varp; 67 unsigned var_idx; 68 unsigned tb_to_us; 69 }; 70 71 struct div_result { 72 u64 result_high; 73 u64 result_low; 74 }; 75 76 /* Accessor functions for the timebase (RTC on 601) registers. */ 77 /* If one day CONFIG_POWER is added just define __USE_RTC as 1 */ 78 #ifdef CONFIG_6xx 79 #define __USE_RTC() (!cpu_has_feature(CPU_FTR_USE_TB)) 80 #else 81 #define __USE_RTC() 0 82 #endif 83 84 #ifdef CONFIG_PPC64 85 86 /* For compatibility, get_tbl() is defined as get_tb() on ppc64 */ 87 #define get_tbl get_tb 88 89 #else 90 91 static inline unsigned long get_tbl(void) 92 { 93 #if defined(CONFIG_403GCX) 94 unsigned long tbl; 95 asm volatile("mfspr %0, 0x3dd" : "=r" (tbl)); 96 return tbl; 97 #else 98 return mftbl(); 99 #endif 100 } 101 102 static inline unsigned int get_tbu(void) 103 { 104 #ifdef CONFIG_403GCX 105 unsigned int tbu; 106 asm volatile("mfspr %0, 0x3dc" : "=r" (tbu)); 107 return tbu; 108 #else 109 return mftbu(); 110 #endif 111 } 112 #endif /* !CONFIG_PPC64 */ 113 114 static inline unsigned int get_rtcl(void) 115 { 116 unsigned int rtcl; 117 118 asm volatile("mfrtcl %0" : "=r" (rtcl)); 119 return rtcl; 120 } 121 122 static inline u64 get_rtc(void) 123 { 124 unsigned int hi, lo, hi2; 125 126 do { 127 asm volatile("mfrtcu %0; mfrtcl %1; mfrtcu %2" 128 : "=r" (hi), "=r" (lo), "=r" (hi2)); 129 } while (hi2 != hi); 130 return (u64)hi * 1000000000 + lo; 131 } 132 133 #ifdef CONFIG_PPC64 134 static inline u64 get_tb(void) 135 { 136 return mftb(); 137 } 138 #else /* CONFIG_PPC64 */ 139 static inline u64 get_tb(void) 140 { 141 unsigned int tbhi, tblo, tbhi2; 142 143 do { 144 tbhi = get_tbu(); 145 tblo = get_tbl(); 146 tbhi2 = get_tbu(); 147 } while (tbhi != tbhi2); 148 149 return ((u64)tbhi << 32) | tblo; 150 } 151 #endif /* !CONFIG_PPC64 */ 152 153 static inline u64 get_tb_or_rtc(void) 154 { 155 return __USE_RTC() ? get_rtc() : get_tb(); 156 } 157 158 static inline void set_tb(unsigned int upper, unsigned int lower) 159 { 160 mtspr(SPRN_TBWL, 0); 161 mtspr(SPRN_TBWU, upper); 162 mtspr(SPRN_TBWL, lower); 163 } 164 165 /* Accessor functions for the decrementer register. 166 * The 4xx doesn't even have a decrementer. I tried to use the 167 * generic timer interrupt code, which seems OK, with the 4xx PIT 168 * in auto-reload mode. The problem is PIT stops counting when it 169 * hits zero. If it would wrap, we could use it just like a decrementer. 170 */ 171 static inline unsigned int get_dec(void) 172 { 173 #if defined(CONFIG_40x) 174 return (mfspr(SPRN_PIT)); 175 #else 176 return (mfspr(SPRN_DEC)); 177 #endif 178 } 179 180 /* 181 * Note: Book E and 4xx processors differ from other PowerPC processors 182 * in when the decrementer generates its interrupt: on the 1 to 0 183 * transition for Book E/4xx, but on the 0 to -1 transition for others. 184 */ 185 static inline void set_dec(int val) 186 { 187 #if defined(CONFIG_40x) 188 mtspr(SPRN_PIT, val); 189 #elif defined(CONFIG_8xx_CPU6) 190 set_dec_cpu6(val - 1); 191 #else 192 #ifndef CONFIG_BOOKE 193 --val; 194 #endif 195 #ifdef CONFIG_PPC_ISERIES 196 if (firmware_has_feature(FW_FEATURE_ISERIES) && 197 get_lppaca()->shared_proc) { 198 get_lppaca()->virtual_decr = val; 199 if (get_dec() > val) 200 HvCall_setVirtualDecr(); 201 return; 202 } 203 #endif 204 mtspr(SPRN_DEC, val); 205 #endif /* not 40x or 8xx_CPU6 */ 206 } 207 208 static inline unsigned long tb_ticks_since(unsigned long tstamp) 209 { 210 if (__USE_RTC()) { 211 int delta = get_rtcl() - (unsigned int) tstamp; 212 return delta < 0 ? delta + 1000000000 : delta; 213 } 214 return get_tbl() - tstamp; 215 } 216 217 #define mulhwu(x,y) \ 218 ({unsigned z; asm ("mulhwu %0,%1,%2" : "=r" (z) : "r" (x), "r" (y)); z;}) 219 220 #ifdef CONFIG_PPC64 221 #define mulhdu(x,y) \ 222 ({unsigned long z; asm ("mulhdu %0,%1,%2" : "=r" (z) : "r" (x), "r" (y)); z;}) 223 #else 224 extern u64 mulhdu(u64, u64); 225 #endif 226 227 extern void smp_space_timers(unsigned int); 228 229 extern unsigned mulhwu_scale_factor(unsigned, unsigned); 230 extern void div128_by_32(u64 dividend_high, u64 dividend_low, 231 unsigned divisor, struct div_result *dr); 232 233 /* Used to store Processor Utilization register (purr) values */ 234 235 struct cpu_usage { 236 u64 current_tb; /* Holds the current purr register values */ 237 }; 238 239 DECLARE_PER_CPU(struct cpu_usage, cpu_usage_array); 240 241 #if defined(CONFIG_VIRT_CPU_ACCOUNTING) 242 extern void calculate_steal_time(void); 243 extern void snapshot_timebases(void); 244 #define account_process_vtime(tsk) account_process_tick(tsk, 0) 245 #else 246 #define calculate_steal_time() do { } while (0) 247 #define snapshot_timebases() do { } while (0) 248 #define account_process_vtime(tsk) do { } while (0) 249 #endif 250 251 extern void secondary_cpu_time_init(void); 252 extern void iSeries_time_init_early(void); 253 254 #endif /* __KERNEL__ */ 255 #endif /* __POWERPC_TIME_H */ 256