1 /* calibrate.c: default delay calibration 2 * 3 * Excised from init/main.c 4 * Copyright (C) 1991, 1992 Linus Torvalds 5 */ 6 7 #include <linux/jiffies.h> 8 #include <linux/delay.h> 9 #include <linux/init.h> 10 #include <linux/timex.h> 11 #include <linux/smp.h> 12 13 unsigned long lpj_fine; 14 unsigned long preset_lpj; 15 static int __init lpj_setup(char *str) 16 { 17 preset_lpj = simple_strtoul(str,NULL,0); 18 return 1; 19 } 20 21 __setup("lpj=", lpj_setup); 22 23 #ifdef ARCH_HAS_READ_CURRENT_TIMER 24 25 /* This routine uses the read_current_timer() routine and gets the 26 * loops per jiffy directly, instead of guessing it using delay(). 27 * Also, this code tries to handle non-maskable asynchronous events 28 * (like SMIs) 29 */ 30 #define DELAY_CALIBRATION_TICKS ((HZ < 100) ? 1 : (HZ/100)) 31 #define MAX_DIRECT_CALIBRATION_RETRIES 5 32 33 static unsigned long __cpuinit calibrate_delay_direct(void) 34 { 35 unsigned long pre_start, start, post_start; 36 unsigned long pre_end, end, post_end; 37 unsigned long start_jiffies; 38 unsigned long timer_rate_min, timer_rate_max; 39 unsigned long good_timer_sum = 0; 40 unsigned long good_timer_count = 0; 41 unsigned long measured_times[MAX_DIRECT_CALIBRATION_RETRIES]; 42 int max = -1; /* index of measured_times with max/min values or not set */ 43 int min = -1; 44 int i; 45 46 if (read_current_timer(&pre_start) < 0 ) 47 return 0; 48 49 /* 50 * A simple loop like 51 * while ( jiffies < start_jiffies+1) 52 * start = read_current_timer(); 53 * will not do. As we don't really know whether jiffy switch 54 * happened first or timer_value was read first. And some asynchronous 55 * event can happen between these two events introducing errors in lpj. 56 * 57 * So, we do 58 * 1. pre_start <- When we are sure that jiffy switch hasn't happened 59 * 2. check jiffy switch 60 * 3. start <- timer value before or after jiffy switch 61 * 4. post_start <- When we are sure that jiffy switch has happened 62 * 63 * Note, we don't know anything about order of 2 and 3. 64 * Now, by looking at post_start and pre_start difference, we can 65 * check whether any asynchronous event happened or not 66 */ 67 68 for (i = 0; i < MAX_DIRECT_CALIBRATION_RETRIES; i++) { 69 pre_start = 0; 70 read_current_timer(&start); 71 start_jiffies = jiffies; 72 while (time_before_eq(jiffies, start_jiffies + 1)) { 73 pre_start = start; 74 read_current_timer(&start); 75 } 76 read_current_timer(&post_start); 77 78 pre_end = 0; 79 end = post_start; 80 while (time_before_eq(jiffies, start_jiffies + 1 + 81 DELAY_CALIBRATION_TICKS)) { 82 pre_end = end; 83 read_current_timer(&end); 84 } 85 read_current_timer(&post_end); 86 87 timer_rate_max = (post_end - pre_start) / 88 DELAY_CALIBRATION_TICKS; 89 timer_rate_min = (pre_end - post_start) / 90 DELAY_CALIBRATION_TICKS; 91 92 /* 93 * If the upper limit and lower limit of the timer_rate is 94 * >= 12.5% apart, redo calibration. 95 */ 96 printk(KERN_DEBUG "calibrate_delay_direct() timer_rate_max=%lu " 97 "timer_rate_min=%lu pre_start=%lu pre_end=%lu\n", 98 timer_rate_max, timer_rate_min, pre_start, pre_end); 99 if (start >= post_end) 100 printk(KERN_NOTICE "calibrate_delay_direct() ignoring " 101 "timer_rate as we had a TSC wrap around" 102 " start=%lu >=post_end=%lu\n", 103 start, post_end); 104 if (start < post_end && pre_start != 0 && pre_end != 0 && 105 (timer_rate_max - timer_rate_min) < (timer_rate_max >> 3)) { 106 good_timer_count++; 107 good_timer_sum += timer_rate_max; 108 measured_times[i] = timer_rate_max; 109 if (max < 0 || timer_rate_max > measured_times[max]) 110 max = i; 111 if (min < 0 || timer_rate_max < measured_times[min]) 112 min = i; 113 } else 114 measured_times[i] = 0; 115 116 } 117 118 /* 119 * Find the maximum & minimum - if they differ too much throw out the 120 * one with the largest difference from the mean and try again... 121 */ 122 while (good_timer_count > 1) { 123 unsigned long estimate; 124 unsigned long maxdiff; 125 126 /* compute the estimate */ 127 estimate = (good_timer_sum/good_timer_count); 128 maxdiff = estimate >> 3; 129 130 /* if range is within 12% let's take it */ 131 if ((measured_times[max] - measured_times[min]) < maxdiff) 132 return estimate; 133 134 /* ok - drop the worse value and try again... */ 135 good_timer_sum = 0; 136 good_timer_count = 0; 137 if ((measured_times[max] - estimate) < 138 (estimate - measured_times[min])) { 139 printk(KERN_NOTICE "calibrate_delay_direct() dropping " 140 "min bogoMips estimate %d = %lu\n", 141 min, measured_times[min]); 142 measured_times[min] = 0; 143 min = max; 144 } else { 145 printk(KERN_NOTICE "calibrate_delay_direct() dropping " 146 "max bogoMips estimate %d = %lu\n", 147 max, measured_times[max]); 148 measured_times[max] = 0; 149 max = min; 150 } 151 152 for (i = 0; i < MAX_DIRECT_CALIBRATION_RETRIES; i++) { 153 if (measured_times[i] == 0) 154 continue; 155 good_timer_count++; 156 good_timer_sum += measured_times[i]; 157 if (measured_times[i] < measured_times[min]) 158 min = i; 159 if (measured_times[i] > measured_times[max]) 160 max = i; 161 } 162 163 } 164 165 printk(KERN_NOTICE "calibrate_delay_direct() failed to get a good " 166 "estimate for loops_per_jiffy.\nProbably due to long platform " 167 "interrupts. Consider using \"lpj=\" boot option.\n"); 168 return 0; 169 } 170 #else 171 static unsigned long __cpuinit calibrate_delay_direct(void) {return 0;} 172 #endif 173 174 /* 175 * This is the number of bits of precision for the loops_per_jiffy. Each 176 * time we refine our estimate after the first takes 1.5/HZ seconds, so try 177 * to start with a good estimate. 178 * For the boot cpu we can skip the delay calibration and assign it a value 179 * calculated based on the timer frequency. 180 * For the rest of the CPUs we cannot assume that the timer frequency is same as 181 * the cpu frequency, hence do the calibration for those. 182 */ 183 #define LPS_PREC 8 184 185 static unsigned long __cpuinit calibrate_delay_converge(void) 186 { 187 /* First stage - slowly accelerate to find initial bounds */ 188 unsigned long lpj, lpj_base, ticks, loopadd, loopadd_base, chop_limit; 189 int trials = 0, band = 0, trial_in_band = 0; 190 191 lpj = (1<<12); 192 193 /* wait for "start of" clock tick */ 194 ticks = jiffies; 195 while (ticks == jiffies) 196 ; /* nothing */ 197 /* Go .. */ 198 ticks = jiffies; 199 do { 200 if (++trial_in_band == (1<<band)) { 201 ++band; 202 trial_in_band = 0; 203 } 204 __delay(lpj * band); 205 trials += band; 206 } while (ticks == jiffies); 207 /* 208 * We overshot, so retreat to a clear underestimate. Then estimate 209 * the largest likely undershoot. This defines our chop bounds. 210 */ 211 trials -= band; 212 loopadd_base = lpj * band; 213 lpj_base = lpj * trials; 214 215 recalibrate: 216 lpj = lpj_base; 217 loopadd = loopadd_base; 218 219 /* 220 * Do a binary approximation to get lpj set to 221 * equal one clock (up to LPS_PREC bits) 222 */ 223 chop_limit = lpj >> LPS_PREC; 224 while (loopadd > chop_limit) { 225 lpj += loopadd; 226 ticks = jiffies; 227 while (ticks == jiffies) 228 ; /* nothing */ 229 ticks = jiffies; 230 __delay(lpj); 231 if (jiffies != ticks) /* longer than 1 tick */ 232 lpj -= loopadd; 233 loopadd >>= 1; 234 } 235 /* 236 * If we incremented every single time possible, presume we've 237 * massively underestimated initially, and retry with a higher 238 * start, and larger range. (Only seen on x86_64, due to SMIs) 239 */ 240 if (lpj + loopadd * 2 == lpj_base + loopadd_base * 2) { 241 lpj_base = lpj; 242 loopadd_base <<= 2; 243 goto recalibrate; 244 } 245 246 return lpj; 247 } 248 249 void __cpuinit calibrate_delay(void) 250 { 251 static bool printed; 252 253 if (preset_lpj) { 254 loops_per_jiffy = preset_lpj; 255 if (!printed) 256 pr_info("Calibrating delay loop (skipped) " 257 "preset value.. "); 258 } else if ((!printed) && lpj_fine) { 259 loops_per_jiffy = lpj_fine; 260 pr_info("Calibrating delay loop (skipped), " 261 "value calculated using timer frequency.. "); 262 } else if ((loops_per_jiffy = calibrate_delay_direct()) != 0) { 263 if (!printed) 264 pr_info("Calibrating delay using timer " 265 "specific routine.. "); 266 } else { 267 if (!printed) 268 pr_info("Calibrating delay loop... "); 269 loops_per_jiffy = calibrate_delay_converge(); 270 } 271 if (!printed) 272 pr_cont("%lu.%02lu BogoMIPS (lpj=%lu)\n", 273 loops_per_jiffy/(500000/HZ), 274 (loops_per_jiffy/(5000/HZ)) % 100, loops_per_jiffy); 275 276 printed = true; 277 } 278