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 if (start >= post_end) 97 printk(KERN_NOTICE "calibrate_delay_direct() ignoring " 98 "timer_rate as we had a TSC wrap around" 99 " start=%lu >=post_end=%lu\n", 100 start, post_end); 101 if (start < post_end && pre_start != 0 && pre_end != 0 && 102 (timer_rate_max - timer_rate_min) < (timer_rate_max >> 3)) { 103 good_timer_count++; 104 good_timer_sum += timer_rate_max; 105 measured_times[i] = timer_rate_max; 106 if (max < 0 || timer_rate_max > measured_times[max]) 107 max = i; 108 if (min < 0 || timer_rate_max < measured_times[min]) 109 min = i; 110 } else 111 measured_times[i] = 0; 112 113 } 114 115 /* 116 * Find the maximum & minimum - if they differ too much throw out the 117 * one with the largest difference from the mean and try again... 118 */ 119 while (good_timer_count > 1) { 120 unsigned long estimate; 121 unsigned long maxdiff; 122 123 /* compute the estimate */ 124 estimate = (good_timer_sum/good_timer_count); 125 maxdiff = estimate >> 3; 126 127 /* if range is within 12% let's take it */ 128 if ((measured_times[max] - measured_times[min]) < maxdiff) 129 return estimate; 130 131 /* ok - drop the worse value and try again... */ 132 good_timer_sum = 0; 133 good_timer_count = 0; 134 if ((measured_times[max] - estimate) < 135 (estimate - measured_times[min])) { 136 printk(KERN_NOTICE "calibrate_delay_direct() dropping " 137 "min bogoMips estimate %d = %lu\n", 138 min, measured_times[min]); 139 measured_times[min] = 0; 140 min = max; 141 } else { 142 printk(KERN_NOTICE "calibrate_delay_direct() dropping " 143 "max bogoMips estimate %d = %lu\n", 144 max, measured_times[max]); 145 measured_times[max] = 0; 146 max = min; 147 } 148 149 for (i = 0; i < MAX_DIRECT_CALIBRATION_RETRIES; i++) { 150 if (measured_times[i] == 0) 151 continue; 152 good_timer_count++; 153 good_timer_sum += measured_times[i]; 154 if (measured_times[i] < measured_times[min]) 155 min = i; 156 if (measured_times[i] > measured_times[max]) 157 max = i; 158 } 159 160 } 161 162 printk(KERN_NOTICE "calibrate_delay_direct() failed to get a good " 163 "estimate for loops_per_jiffy.\nProbably due to long platform " 164 "interrupts. Consider using \"lpj=\" boot option.\n"); 165 return 0; 166 } 167 #else 168 static unsigned long __cpuinit calibrate_delay_direct(void) {return 0;} 169 #endif 170 171 /* 172 * This is the number of bits of precision for the loops_per_jiffy. Each 173 * time we refine our estimate after the first takes 1.5/HZ seconds, so try 174 * to start with a good estimate. 175 * For the boot cpu we can skip the delay calibration and assign it a value 176 * calculated based on the timer frequency. 177 * For the rest of the CPUs we cannot assume that the timer frequency is same as 178 * the cpu frequency, hence do the calibration for those. 179 */ 180 #define LPS_PREC 8 181 182 static unsigned long __cpuinit calibrate_delay_converge(void) 183 { 184 /* First stage - slowly accelerate to find initial bounds */ 185 unsigned long lpj, lpj_base, ticks, loopadd, loopadd_base, chop_limit; 186 int trials = 0, band = 0, trial_in_band = 0; 187 188 lpj = (1<<12); 189 190 /* wait for "start of" clock tick */ 191 ticks = jiffies; 192 while (ticks == jiffies) 193 ; /* nothing */ 194 /* Go .. */ 195 ticks = jiffies; 196 do { 197 if (++trial_in_band == (1<<band)) { 198 ++band; 199 trial_in_band = 0; 200 } 201 __delay(lpj * band); 202 trials += band; 203 } while (ticks == jiffies); 204 /* 205 * We overshot, so retreat to a clear underestimate. Then estimate 206 * the largest likely undershoot. This defines our chop bounds. 207 */ 208 trials -= band; 209 loopadd_base = lpj * band; 210 lpj_base = lpj * trials; 211 212 recalibrate: 213 lpj = lpj_base; 214 loopadd = loopadd_base; 215 216 /* 217 * Do a binary approximation to get lpj set to 218 * equal one clock (up to LPS_PREC bits) 219 */ 220 chop_limit = lpj >> LPS_PREC; 221 while (loopadd > chop_limit) { 222 lpj += loopadd; 223 ticks = jiffies; 224 while (ticks == jiffies) 225 ; /* nothing */ 226 ticks = jiffies; 227 __delay(lpj); 228 if (jiffies != ticks) /* longer than 1 tick */ 229 lpj -= loopadd; 230 loopadd >>= 1; 231 } 232 /* 233 * If we incremented every single time possible, presume we've 234 * massively underestimated initially, and retry with a higher 235 * start, and larger range. (Only seen on x86_64, due to SMIs) 236 */ 237 if (lpj + loopadd * 2 == lpj_base + loopadd_base * 2) { 238 lpj_base = lpj; 239 loopadd_base <<= 2; 240 goto recalibrate; 241 } 242 243 return lpj; 244 } 245 246 void __cpuinit calibrate_delay(void) 247 { 248 unsigned long lpj; 249 static bool printed; 250 251 if (preset_lpj) { 252 lpj = preset_lpj; 253 if (!printed) 254 pr_info("Calibrating delay loop (skipped) " 255 "preset value.. "); 256 } else if ((!printed) && lpj_fine) { 257 lpj = lpj_fine; 258 pr_info("Calibrating delay loop (skipped), " 259 "value calculated using timer frequency.. "); 260 } else if ((lpj = calibrate_delay_direct()) != 0) { 261 if (!printed) 262 pr_info("Calibrating delay using timer " 263 "specific routine.. "); 264 } else { 265 if (!printed) 266 pr_info("Calibrating delay loop... "); 267 lpj = calibrate_delay_converge(); 268 } 269 if (!printed) 270 pr_cont("%lu.%02lu BogoMIPS (lpj=%lu)\n", 271 lpj/(500000/HZ), 272 (lpj/(5000/HZ)) % 100, lpj); 273 274 loops_per_jiffy = lpj; 275 printed = true; 276 } 277