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 int i; 42 43 if (read_current_timer(&pre_start) < 0 ) 44 return 0; 45 46 /* 47 * A simple loop like 48 * while ( jiffies < start_jiffies+1) 49 * start = read_current_timer(); 50 * will not do. As we don't really know whether jiffy switch 51 * happened first or timer_value was read first. And some asynchronous 52 * event can happen between these two events introducing errors in lpj. 53 * 54 * So, we do 55 * 1. pre_start <- When we are sure that jiffy switch hasn't happened 56 * 2. check jiffy switch 57 * 3. start <- timer value before or after jiffy switch 58 * 4. post_start <- When we are sure that jiffy switch has happened 59 * 60 * Note, we don't know anything about order of 2 and 3. 61 * Now, by looking at post_start and pre_start difference, we can 62 * check whether any asynchronous event happened or not 63 */ 64 65 for (i = 0; i < MAX_DIRECT_CALIBRATION_RETRIES; i++) { 66 pre_start = 0; 67 read_current_timer(&start); 68 start_jiffies = jiffies; 69 while (time_before_eq(jiffies, start_jiffies + 1)) { 70 pre_start = start; 71 read_current_timer(&start); 72 } 73 read_current_timer(&post_start); 74 75 pre_end = 0; 76 end = post_start; 77 while (time_before_eq(jiffies, start_jiffies + 1 + 78 DELAY_CALIBRATION_TICKS)) { 79 pre_end = end; 80 read_current_timer(&end); 81 } 82 read_current_timer(&post_end); 83 84 timer_rate_max = (post_end - pre_start) / 85 DELAY_CALIBRATION_TICKS; 86 timer_rate_min = (pre_end - post_start) / 87 DELAY_CALIBRATION_TICKS; 88 89 /* 90 * If the upper limit and lower limit of the timer_rate is 91 * >= 12.5% apart, redo calibration. 92 */ 93 if (pre_start != 0 && pre_end != 0 && 94 (timer_rate_max - timer_rate_min) < (timer_rate_max >> 3)) { 95 good_timer_count++; 96 good_timer_sum += timer_rate_max; 97 } 98 } 99 100 if (good_timer_count) 101 return (good_timer_sum/good_timer_count); 102 103 printk(KERN_WARNING "calibrate_delay_direct() failed to get a good " 104 "estimate for loops_per_jiffy.\nProbably due to long platform interrupts. Consider using \"lpj=\" boot option.\n"); 105 return 0; 106 } 107 #else 108 static unsigned long __cpuinit calibrate_delay_direct(void) {return 0;} 109 #endif 110 111 /* 112 * This is the number of bits of precision for the loops_per_jiffy. Each 113 * time we refine our estimate after the first takes 1.5/HZ seconds, so try 114 * to start with a good estimate. 115 * For the boot cpu we can skip the delay calibration and assign it a value 116 * calculated based on the timer frequency. 117 * For the rest of the CPUs we cannot assume that the timer frequency is same as 118 * the cpu frequency, hence do the calibration for those. 119 */ 120 #define LPS_PREC 8 121 122 static unsigned long __cpuinit calibrate_delay_converge(void) 123 { 124 /* First stage - slowly accelerate to find initial bounds */ 125 unsigned long lpj, lpj_base, ticks, loopadd, loopadd_base, chop_limit; 126 int trials = 0, band = 0, trial_in_band = 0; 127 128 lpj = (1<<12); 129 130 /* wait for "start of" clock tick */ 131 ticks = jiffies; 132 while (ticks == jiffies) 133 ; /* nothing */ 134 /* Go .. */ 135 ticks = jiffies; 136 do { 137 if (++trial_in_band == (1<<band)) { 138 ++band; 139 trial_in_band = 0; 140 } 141 __delay(lpj * band); 142 trials += band; 143 } while (ticks == jiffies); 144 /* 145 * We overshot, so retreat to a clear underestimate. Then estimate 146 * the largest likely undershoot. This defines our chop bounds. 147 */ 148 trials -= band; 149 loopadd_base = lpj * band; 150 lpj_base = lpj * trials; 151 152 recalibrate: 153 lpj = lpj_base; 154 loopadd = loopadd_base; 155 156 /* 157 * Do a binary approximation to get lpj set to 158 * equal one clock (up to LPS_PREC bits) 159 */ 160 chop_limit = lpj >> LPS_PREC; 161 while (loopadd > chop_limit) { 162 lpj += loopadd; 163 ticks = jiffies; 164 while (ticks == jiffies) 165 ; /* nothing */ 166 ticks = jiffies; 167 __delay(lpj); 168 if (jiffies != ticks) /* longer than 1 tick */ 169 lpj -= loopadd; 170 loopadd >>= 1; 171 } 172 /* 173 * If we incremented every single time possible, presume we've 174 * massively underestimated initially, and retry with a higher 175 * start, and larger range. (Only seen on x86_64, due to SMIs) 176 */ 177 if (lpj + loopadd * 2 == lpj_base + loopadd_base * 2) { 178 lpj_base = lpj; 179 loopadd_base <<= 2; 180 goto recalibrate; 181 } 182 183 return lpj; 184 } 185 186 void __cpuinit calibrate_delay(void) 187 { 188 static bool printed; 189 190 if (preset_lpj) { 191 loops_per_jiffy = preset_lpj; 192 if (!printed) 193 pr_info("Calibrating delay loop (skipped) " 194 "preset value.. "); 195 } else if ((!printed) && lpj_fine) { 196 loops_per_jiffy = lpj_fine; 197 pr_info("Calibrating delay loop (skipped), " 198 "value calculated using timer frequency.. "); 199 } else if ((loops_per_jiffy = calibrate_delay_direct()) != 0) { 200 if (!printed) 201 pr_info("Calibrating delay using timer " 202 "specific routine.. "); 203 } else { 204 if (!printed) 205 pr_info("Calibrating delay loop... "); 206 loops_per_jiffy = calibrate_delay_converge(); 207 } 208 if (!printed) 209 pr_cont("%lu.%02lu BogoMIPS (lpj=%lu)\n", 210 loops_per_jiffy/(500000/HZ), 211 (loops_per_jiffy/(5000/HZ)) % 100, loops_per_jiffy); 212 213 printed = true; 214 } 215