Merge git://git.kernel.org/pub/scm/linux/kernel/git/jejb/scsi-misc-2.6
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / init / calibrate.c
blobcfd7000c9d7108085b337876893fa6e91910dc04
1 /* calibrate.c: default delay calibration
3 * Excised from init/main.c
4 * Copyright (C) 1991, 1992 Linus Torvalds
5 */
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>
13 unsigned long lpj_fine;
14 unsigned long preset_lpj;
15 static int __init lpj_setup(char *str)
17 preset_lpj = simple_strtoul(str,NULL,0);
18 return 1;
21 __setup("lpj=", lpj_setup);
23 #ifdef ARCH_HAS_READ_CURRENT_TIMER
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)
30 #define DELAY_CALIBRATION_TICKS ((HZ < 100) ? 1 : (HZ/100))
31 #define MAX_DIRECT_CALIBRATION_RETRIES 5
33 static unsigned long __cpuinit calibrate_delay_direct(void)
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;
46 if (read_current_timer(&pre_start) < 0 )
47 return 0;
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.
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
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
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);
76 read_current_timer(&post_start);
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);
85 read_current_timer(&post_end);
87 timer_rate_max = (post_end - pre_start) /
88 DELAY_CALIBRATION_TICKS;
89 timer_rate_min = (pre_end - post_start) /
90 DELAY_CALIBRATION_TICKS;
93 * If the upper limit and lower limit of the timer_rate is
94 * >= 12.5% apart, redo calibration.
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;
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...
122 while (good_timer_count > 1) {
123 unsigned long estimate;
124 unsigned long maxdiff;
126 /* compute the estimate */
127 estimate = (good_timer_sum/good_timer_count);
128 maxdiff = estimate >> 3;
130 /* if range is within 12% let's take it */
131 if ((measured_times[max] - measured_times[min]) < maxdiff)
132 return estimate;
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;
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;
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;
170 #else
171 static unsigned long __cpuinit calibrate_delay_direct(void) {return 0;}
172 #endif
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.
183 #define LPS_PREC 8
185 static unsigned long __cpuinit calibrate_delay_converge(void)
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;
191 lpj = (1<<12);
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;
204 __delay(lpj * band);
205 trials += band;
206 } while (ticks == jiffies);
208 * We overshot, so retreat to a clear underestimate. Then estimate
209 * the largest likely undershoot. This defines our chop bounds.
211 trials -= band;
212 loopadd_base = lpj * band;
213 lpj_base = lpj * trials;
215 recalibrate:
216 lpj = lpj_base;
217 loopadd = loopadd_base;
220 * Do a binary approximation to get lpj set to
221 * equal one clock (up to LPS_PREC bits)
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;
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)
240 if (lpj + loopadd * 2 == lpj_base + loopadd_base * 2) {
241 lpj_base = lpj;
242 loopadd_base <<= 2;
243 goto recalibrate;
246 return lpj;
249 void __cpuinit calibrate_delay(void)
251 static bool printed;
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();
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);
276 printed = true;